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
feat(redis): add custom key groups
Guoyu Su1cbb5abf3bd1
diff --git a/apps/desktop/src/components/connection/ConnectionDialog.vue b/apps/desktop/src/components/connection/ConnectionDialog.vueindex 07ee65f710..dd7fc9e95c 100644--- a/apps/desktop/src/components/connection/ConnectionDialog.vue+++ b/apps/desktop/src/components/connection/ConnectionDialog.vue@@ -2541,6 +2541,7 @@ watch(redis_key_separator: config.redis_key_separator ?? ":",redis_scan_page_size: config.redis_scan_page_size ?? REDIS_SCAN_PAGE_SIZE_DEFAULT,redis_key_templates: normalizeRedisKeyTemplates(config.redis_key_templates),+ redis_key_grouping: config.redis_key_grouping,etcd_endpoints: config.etcd_endpoints || "",gbase_server: config.gbase_server || "",informix_server: config.informix_server || "",@@ -4038,6 +4039,7 @@ function connectionConfigForSubmit(id: string, generatedName = ""): ConnectionCoconfig.redis_scan_page_size = undefined;config.redis_database_aliases = undefined;config.redis_key_templates = undefined;+ config.redis_key_grouping = undefined;} else if (config.redis_connection_mode === "sentinel") {config.redis_sentinel_master = config.redis_sentinel_master?.trim() || "";config.redis_sentinel_nodes = normalizeRedisSentinelNodes(config.redis_sentinel_nodes || "");diff --git a/apps/desktop/src/components/redis/RedisGroupHeader.vue b/apps/desktop/src/components/redis/RedisGroupHeader.vuenew file mode 100644index 0000000000..248b8aafb1--- /dev/null+++ b/apps/desktop/src/components/redis/RedisGroupHeader.vue@@ -0,0 +1,40 @@+<script setup lang="ts">+import { ChevronDown, ChevronRight } from "@lucide/vue";+import { useI18n } from "vue-i18n";+import { useId } from "vue";+import type { RedisVirtualGroupRow } from "@/lib/redis/redisKeyGroupIndex";++defineProps<{ row: RedisVirtualGroupRow; expanded: boolean; navigation?: boolean; omitted?: boolean; path?: string; stickyDepth?: number }>();+const emit = defineEmits<{ toggle: []; navigate: [] }>();+const { t } = useI18n();+const pathHintId = useId();+</script>++<template>+ <div v-if="navigation" class="group/redis-sticky relative flex h-[30px] items-center gap-1 border-b bg-background px-2 text-xs" :style="{ paddingLeft: `${8 + (stickyDepth ?? row.depth) * 10}px` }" :title="path">+ <button type="button" class="flex h-6 w-5 shrink-0 items-center justify-center hover:bg-accent/40 focus-visible:outline focus-visible:outline-ring" data-redis-sticky-toggle :aria-label="row.label" :aria-describedby="pathHintId" :aria-expanded="expanded" @click="emit('toggle')">+ <component :is="expanded ? ChevronDown : ChevronRight" class="h-3 w-3" />+ </button>+ <button type="button" class="flex h-full min-w-0 flex-1 items-center gap-1 text-left hover:bg-accent/40 focus-visible:outline focus-visible:outline-ring" data-redis-sticky-navigate :aria-label="row.label" :aria-describedby="pathHintId" :title="path" @click="emit('navigate')">+ <span v-if="omitted" aria-hidden="true">…</span>+ <span class="truncate">{{ row.label }}</span>+ <span class="shrink-0 text-muted-foreground">{{ t("redisGrouping.count", { count: row.count }) }}</span>+ </button>+ <span :id="pathHintId" role="tooltip" class="pointer-events-none absolute inset-x-0 top-full z-30 hidden break-all rounded border bg-popover p-2 text-popover-foreground shadow-md group-hover/redis-sticky:block group-focus-within/redis-sticky:block">{{ path }}</span>+ </div>+ <div+ v-else+ class="flex h-[30px] cursor-pointer items-center gap-1 border-b px-2 text-xs hover:bg-accent/40 focus-visible:outline focus-visible:outline-ring focus-visible:outline-offset-[-2px]"+ :style="{ paddingLeft: `${8 + row.depth * 10}px` }"+ role="button"+ tabindex="0"+ :aria-expanded="expanded"+ @click="emit('toggle')"+ @keydown.enter.prevent="emit('toggle')"+ @keydown.space.prevent="emit('toggle')"+ >+ <component :is="expanded ? ChevronDown : ChevronRight" class="h-3 w-3 shrink-0" />+ <span class="truncate">{{ row.label }}</span>+ <span class="shrink-0 text-muted-foreground">{{ t("redisGrouping.count", { count: row.count }) }}</span>+ </div>+</template>diff --git a/apps/desktop/src/components/redis/RedisGroupedKeyList.publication.spec.ts b/apps/desktop/src/components/redis/RedisGroupedKeyList.publication.spec.tsnew file mode 100644index 0000000000..9404e02534--- /dev/null+++ b/apps/desktop/src/components/redis/RedisGroupedKeyList.publication.spec.ts@@ -0,0 +1,239 @@+// @vitest-environment happy-dom+import { createApp, defineComponent, h, nextTick, shallowRef } from "vue";+import { afterEach, expect, it, vi } from "vitest";+import type { RedisKeyInfo } from "@/lib/backend/api";+import { defaultRedisKeyGrouping } from "@/lib/redis/redisKeyGrouping";+import RedisGroupedKeyList from "./RedisGroupedKeyList.vue";++// Deliberately use the installed RecycleScroller, not a mock that rerenders+// whenever updateVisibleItems is called. Same-ID headers must really rebind.+vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string, values?: { count: number }) => (values ? `${key}:${values.count}` : key) }) }));++const cleanups: (() => void)[] = [];+afterEach(() => {+ cleanups.splice(0).forEach((cleanup) => cleanup());+ vi.restoreAllMocks();+ vi.useRealTimers();+});++function mountGroups(customConfig = { ...defaultRedisKeyGrouping(), enabled: true }) {+ const height = vi.spyOn(HTMLElement.prototype, "clientHeight", "get").mockReturnValue(300);+ vi.spyOn(HTMLElement.prototype, "clientWidth", "get").mockReturnValue(600);+ const keys = shallowRef<RedisKeyInfo[]>([]);+ const scope = shallowRef("c:0");+ const host = document.createElement("div");+ document.body.appendChild(host);+ const config = shallowRef(customConfig);+ const checked = new Set<string>();+ const selected = shallowRef<string | null>(null);+ const onSelect = vi.fn();+ const onCheck = vi.fn();+ const list = shallowRef<InstanceType<typeof RedisGroupedKeyList> | null>(null);+ const app = createApp(+ defineComponent({+ setup: () => () => h(RedisGroupedKeyList, { ref: list, keys: keys.value, config: config.value, scope: scope.value, structureRevision: 0, separator: ":", selected: selected.value, checked, busy: false, metadataEpoch: 0, treeAllowed: true, onSelect, onCheck }),+ }),+ );+ app.mount(host);+ let mounted = true;+ const unmount = () => {+ if (!mounted) return;+ mounted = false;+ app.unmount();+ host.remove();+ };+ cleanups.push(unmount);+ return { host, keys, scope, config, checked, selected, onSelect, onCheck, list, unmount, height };+}++function key(n: number): RedisKeyInfo {+ return { key_raw: btoa(`key:${n}`), key_display: `key:${n}`, ttl: -1, key_type: "string" };+}++async function flushPublication() {+ if (!vi.isFakeTimers()) await new Promise((resolve) => setTimeout(resolve, 20));+ for (let i = 0; i < 12; i++) await nextTick();+}++it("automatically rebinds same-ID group counts through the real scroller", async () => {+ const { host, keys } = mountGroups();+ keys.value = [key(0)];+ await flushPublication();+ expect(host.textContent).toContain("redisGrouping.count:1");+ const header = host.querySelector('[role="button"]');+ keys.value = [...keys.value, key(1), key(2)];+ await flushPublication();+ expect(host.textContent).toContain("redisGrouping.count:3");+ expect(host.textContent).not.toContain("redisGrouping.preparing");+ expect(host.querySelector('[role="button"]')).toBe(header);+});++it("finishes without interaction when timers are delayed instead of paying a timer per checkpoint", async () => {+ vi.useFakeTimers();+ let workTime = 0;+ vi.spyOn(performance, "now").mockImplementation(() => workTime++);+ const timer = globalThis.setTimeout;+ vi.spyOn(globalThis, "setTimeout").mockImplementation(((callback, delay, ...args) => timer(callback, Math.max(1000, delay ?? 0), ...args)) as typeof setTimeout);+ const { host, keys } = mountGroups();+ keys.value = [key(0)];+ await flushPublication();+ expect(host.textContent).toContain("redisGrouping.count:1");+ keys.value = Array.from({ length: 10_000 }, (_, n) => key(n));+ await flushPublication();+ expect(host.textContent).toContain("redisGrouping.preparing");+ // 20 chunks, but only two exhausted 8ms work budgets.+ await vi.advanceTimersByTimeAsync(3000);+ await flushPublication();+ expect(host.textContent).toContain("redisGrouping.count:10000");+ expect(host.textContent).not.toContain("redisGrouping.preparing");+});++it("does not publish a delayed build after changing database scope", async () => {+ vi.useFakeTimers();+ let workTime = 0;+ vi.spyOn(performance, "now").mockImplementation(() => workTime++);+ const { host, keys, scope } = mountGroups();+ keys.value = Array.from({ length: 10_000 }, (_, n) => key(n));+ await flushPublication();+ expect(host.textContent).toContain("redisGrouping.preparing");+ scope.value = "c:1";+ keys.value = [key(20_000), key(20_001)];+ await flushPublication();+ await vi.advanceTimersByTimeAsync(1000);+ await flushPublication();+ expect(host.textContent).toContain("redisGrouping.count:2");+ expect(host.textContent).not.toContain("redisGrouping.count:10000");+ expect(host.textContent).not.toContain("redisGrouping.preparing");+});++it("cancels a delayed build on unmount without trying to refresh its scroller", async () => {+ vi.useFakeTimers();+ let workTime = 0;+ vi.spyOn(performance, "now").mockImplementation(() => workTime++);+ const { host, keys, unmount } = mountGroups();+ keys.value = Array.from({ length: 10_000 }, (_, n) => key(n));+ await flushPublication();+ expect(host.textContent).toContain("redisGrouping.preparing");+ unmount();+ await vi.advanceTimersByTimeAsync(1000);+ expect(vi.getTimerCount()).toBe(0);+ expect(host.childNodes).toHaveLength(0);+});++it.each(["list", "tree"] as const)("pins the allowed ancestors in %s and collapses to a reachable header without changing selection", async (inner_view) => {+ const state = mountGroups({ ...defaultRedisKeyGrouping(), enabled: true, inner_view });+ state.keys.value = Array.from({ length: 200 }, (_, n) => key(n));+ await flushPublication();+ const outer = () => state.host.querySelector<HTMLElement>('[data-redis-group-header="custom:unmatched"]')!;+ expect(state.host.querySelector("[data-redis-sticky-group]")).toBeNull();+ expect(outer()).not.toBeNull();+ outer().click();+ await flushPublication();+ if (inner_view === "tree") {+ state.host.querySelector<HTMLElement>('[data-redis-group-header*="namespace"]')!.click();+ await flushPublication();+ }+ state.checked.add(key(20).key_raw);+ state.selected.value = key(20).key_raw;+ await nextTick();+ const element = state.host.querySelector<HTMLElement>(".redis-key-scroller")!;+ element.scrollTop = 1500;+ element.dispatchEvent(new Event("scroll"));+ await nextTick();+ const pinned = state.host.querySelector<HTMLElement>("[data-redis-sticky-group]")!;+ expect(pinned.dataset.redisStickyGroup).toBe("custom:unmatched");+ expect(pinned.textContent).toContain("redisGrouping.count:200");+ expect((inner_view === "tree" ? pinned.querySelector("[data-redis-sticky-toggle]")! : pinned).getAttribute("aria-expanded")).toBe("true");+ expect(state.host.querySelectorAll("[data-redis-sticky-group]")).toHaveLength(inner_view === "tree" ? 2 : 1);+ // The outgoing legacy-view anchor must identify a visible descendant, not+ // the row hidden beneath the pinned header. Tree adds its namespace row.+ expect(state.list.value!.getViewportAnchor()).toEqual({ rowIndex: inner_view === "tree" ? 52 : 51, keyRaw: key(50).key_raw });+ if (inner_view === "tree") pinned.querySelector<HTMLButtonElement>("[data-redis-sticky-toggle]")!.click();+ else pinned.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));+ await flushPublication();+ expect(element.scrollTop).toBe(0);+ expect(outer().getAttribute("aria-expanded")).toBe("false");+ expect(document.activeElement).toBe(outer());+ expect(state.host.querySelector("[data-redis-sticky-group]")).toBeNull();+ expect(state.checked.has(key(20).key_raw)).toBe(true);+ expect(state.selected.value).toBe(key(20).key_raw);+ expect(state.onSelect).not.toHaveBeenCalled();+ expect(state.onCheck).not.toHaveBeenCalled();+});++it("pushes off at the next group, switches its identity and clears stale headers on scope replacement", async () => {+ const state = mountGroups({ ...defaultRedisKeyGrouping(), enabled: true, rules: [{ id: "first", name: "First", enabled: true, includes: ["key:?"], excludes: [] }] });+ state.keys.value = Array.from({ length: 200 }, (_, n) => key(n));+ await flushPublication();+ Array.from(state.host.querySelectorAll<HTMLElement>("[data-redis-group-header]"))+ .find((node) => node.dataset.redisGroupHeader === 'custom:"first"')!+ .click();+ await flushPublication();+ state.host.querySelector<HTMLElement>('[data-redis-group-header="custom:unmatched"]')!.click();+ await flushPublication();+ const element = state.host.querySelector<HTMLElement>(".redis-key-scroller")!;+ // First has 10 keys + its header; next boundary is at 11 * 30.+ element.scrollTop = 11 * 30 - 15;+ element.dispatchEvent(new Event("scroll"));+ await nextTick();+ let pinned = state.host.querySelector<HTMLElement>("[data-redis-sticky-group]")!;+ expect(pinned).not.toBeNull();+ expect(pinned.dataset.redisStickyGroup).toBe('custom:"first"');+ expect(pinned.parentElement!.style.transform).toBe("translateY(-15px)");+ // During push-off only 15px is covered; the next natural header is visible.+ expect(state.list.value!.getViewportAnchor()).toEqual({ rowIndex: 11, keyRaw: undefined });+ element.scrollTop = 12 * 30;+ element.dispatchEvent(new Event("scroll"));+ await nextTick();+ pinned = state.host.querySelector<HTMLElement>("[data-redis-sticky-group]")!;+ expect(pinned.dataset.redisStickyGroup).toBe("custom:unmatched");+ state.scope.value = "c:1";+ state.keys.value = [];+ await flushPublication();+ expect(state.host.querySelector("[data-redis-sticky-group]")).toBeNull();+});++it("compresses deep ancestors, navigates without collapsing and restores an inner collapse through the installed scroller", async () => {+ const state = mountGroups({ ...defaultRedisKeyGrouping(), enabled: true, inner_view: "tree" });+ const names = Array.from({ length: 200 }, (_, n) => `a:b:c:d:${n}`);+ state.keys.value = names.map((name) => ({ key_display: name, key_raw: btoa(name), ttl: -1, key_type: "string" }));+ await flushPublication();+ const natural = (id: string) => Array.from(state.host.querySelectorAll<HTMLElement>("[data-redis-group-header]")).find((node) => node.dataset.redisGroupHeader === id)!;+ const namespace = (parts: string[]) => `custom:unmatched:namespace:${JSON.stringify(parts)}`;+ for (const id of ["custom:unmatched", namespace(["a"]), namespace(["a", "b"]), namespace(["a", "b", "c"]), namespace(["a", "b", "c", "d"])]) {+ natural(id).click();+ await flushPublication();+ }+ const element = state.host.querySelector<HTMLElement>(".redis-key-scroller")!;+ const scroll = async (top: number) => {+ element.scrollTop = top;+ element.dispatchEvent(new Event("scroll"));+ await nextTick();+ };+ const pinned = () => Array.from(state.host.querySelectorAll<HTMLElement>("[data-redis-sticky-group]"));+ expect(natural(namespace(["a", "b", "c", "d"])).style.paddingLeft).toBe("48px");+ await scroll(1500);+ expect(pinned().map((node) => node.dataset.redisStickyGroup)).toEqual(["custom:unmatched", namespace(["a", "b", "c"]), namespace(["a", "b", "c", "d"])]);+ expect(pinned().map((node) => node.style.paddingLeft)).toEqual(["8px", "18px", "28px"]);+ expect(pinned()[1]!.textContent).toContain("…");+ expect(pinned()[1]!.querySelector("[data-redis-sticky-navigate]")!.getAttribute("aria-label")).toBe("c");+ expect(pinned()[1]!.querySelector('[role="tooltip"]')!.textContent).toContain("a › b › c › d");+ expect(pinned()[1]!.querySelectorAll("button button")).toHaveLength(0);+ expect(state.list.value!.getViewportAnchor()).toEqual({ rowIndex: 53, keyRaw: btoa(names[48]!) });+ state.checked.add(btoa(names[48]!));+ state.selected.value = btoa(names[48]!);+ pinned()[1]!.querySelector<HTMLButtonElement>("[data-redis-sticky-navigate]")!.click();+ await flushPublication();+ expect(natural(namespace(["a", "b", "c"])).getAttribute("aria-expanded")).toBe("true");+ expect(document.activeElement).toBe(natural(namespace(["a", "b", "c"])));+ await scroll(1500);+ pinned()[1]!.querySelector<HTMLButtonElement>("[data-redis-sticky-toggle]")!.click();+ await flushPublication();+ expect(natural(namespace(["a", "b", "c"])).getAttribute("aria-expanded")).toBe("false");+ expect(pinned().some((node) => node.dataset.redisStickyGroup === namespace(["a", "b", "c", "d"]))).toBe(false);+ expect(document.activeElement).toBe(natural(namespace(["a", "b", "c"])));+ expect(state.checked).toEqual(new Set([btoa(names[48]!)]));+ expect(state.selected.value).toBe(btoa(names[48]!));+ expect(state.onCheck).not.toHaveBeenCalled();+ expect(state.onSelect).not.toHaveBeenCalled();+});diff --git a/apps/desktop/src/components/redis/RedisGroupedKeyList.spec.ts b/apps/desktop/src/components/redis/RedisGroupedKeyList.spec.tsnew file mode 100644index 0000000000..f70c8149c5--- /dev/null+++ b/apps/desktop/src/components/redis/RedisGroupedKeyList.spec.ts@@ -0,0 +1,98 @@+// @vitest-environment happy-dom+import { createApp, defineComponent, h, nextTick, ref } from "vue";+import { afterEach, expect, it, vi } from "vitest";+import { defaultRedisKeyGrouping } from "@/lib/redis/redisKeyGrouping";+import RedisGroupedKeyList from "./RedisGroupedKeyList.vue";++vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key }) }));+const refresh = vi.fn();+const scroll = vi.fn();+let bound: unknown;+vi.mock("vue-virtual-scroller", () => ({+ RecycleScroller: defineComponent({+ props: ["items"],+ setup(props, { slots, expose }) {+ bound = props.items;+ const epoch = ref(0);+ expose({+ findItemIndex: () => 0,+ getScroll: () => ({ start: 0 }),+ scrollToItem: scroll,+ updateVisibleItems: (changed: boolean) => {+ refresh(changed);+ epoch.value++;+ },+ });+ return () => {+ void epoch.value;+ return h(+ "div",+ Array.from(props.items as unknown[]).map((item) => slots.default?.({ item })),+ );+ };+ },+ }),+}));+afterEach(() => vi.clearAllMocks());++it("does not build a fuzzy tree over the existing limit or silently switch views", async () => {+ const config = { ...defaultRedisKeyGrouping(), enabled: true, inner_view: "tree" as const };+ const requestList = vi.fn();+ const host = document.createElement("div");+ document.body.appendChild(host);+ const app = createApp(RedisGroupedKeyList, { keys: [], config, scope: "c:0", structureRevision: 0, separator: ":", selected: null, checked: new Set(), busy: false, metadataEpoch: 0, treeAllowed: false, onRequestList: requestList });+ app.mount(host);+ await nextTick();+ expect(host.querySelector(".redis-key-scroller")).toBeNull();+ expect(host.textContent).toContain("redisGrouping.fuzzyTreeUnavailable");+ expect(requestList).not.toHaveBeenCalled();+ expect(config.inner_view).toBe("tree");+ host.querySelector<HTMLButtonElement>("button")!.click();+ expect(requestList).toHaveBeenCalledOnce();+ app.unmount();+ host.remove();+});++it("headers have no check/delete controls and expanding is local", async () => {+ const config = { ...defaultRedisKeyGrouping(), enabled: true };+ const deleted = vi.fn();+ const scrolled = vi.fn();+ const resized = vi.fn();+ const host = document.createElement("div");+ document.body.appendChild(host);+ const app = createApp(RedisGroupedKeyList, {+ keys: [{ key_raw: btoa("a"), key_display: "a", ttl: -1, key_type: "string" }],+ config,+ scope: "c:0",+ structureRevision: 0,+ separator: ":",+ selected: null,+ checked: new Set(),+ busy: false,+ metadataEpoch: 0,+ onDelete: deleted,+ onScroll: scrolled,+ onResize: resized,+ });+ app.mount(host);+ await new Promise((resolve) => setTimeout(resolve, 0));+ await nextTick();+ const original = bound;+ expect(host.querySelectorAll('input[type="checkbox"]')).toHaveLength(0);+ expect(host.querySelectorAll("button")).toHaveLength(0);+ host.querySelector<HTMLElement>('[role="button"]')!.click();+ await new Promise((resolve) => setTimeout(resolve, 0));+ await nextTick();+ expect(bound).toBe(original);+ expect(refresh).toHaveBeenCalledWith(true);+ expect(host.querySelectorAll('input[type="checkbox"]')).toHaveLength(1);+ expect(deleted).not.toHaveBeenCalled();+ const element = host.querySelector<HTMLElement>(".redis-key-scroller")!;+ element.dispatchEvent(new Event("scroll"));+ element.dispatchEvent(new Event("resize"));+ expect(scrolled).toHaveBeenCalledOnce();+ expect(scrolled.mock.calls[0]![0].target).toBe(element);+ expect(resized).toHaveBeenCalledOnce();+ app.unmount();+ host.remove();+});diff --git a/apps/desktop/src/components/redis/RedisGroupedKeyList.vue b/apps/desktop/src/components/redis/RedisGroupedKeyList.vuenew file mode 100644index 0000000000..c102044232--- /dev/null+++ b/apps/desktop/src/components/redis/RedisGroupedKeyList.vue@@ -0,0 +1,246 @@+<script setup lang="ts">+import { computed, markRaw, nextTick, onActivated, onDeactivated, onUnmounted, ref, shallowRef, watch } from "vue";+import { RecycleScroller } from "vue-virtual-scroller";+import { KeyRound, Trash2, Copy } from "@lucide/vue";+import { useI18n } from "vue-i18n";+import { Button } from "@/components/ui/button";+import CustomContextMenu from "@/components/ui/CustomContextMenu.vue";+import type { RedisKeyInfo } from "@/lib/backend/api";+import type { RedisKeyGrouping } from "@/lib/redis/redisKeyGrouping";+import { RedisKeyGroupIndex, type RedisGroupedRow, type RedisOuterGroupBoundary, type RedisHeaderBoundary } from "@/lib/redis/redisKeyGroupIndex";+import { redisStickyHeaders, redisStickyHeight, REDIS_GROUP_ROW_HEIGHT } from "@/lib/redis/redisStickyHeaders";+import RedisGroupHeader from "./RedisGroupHeader.vue";+import { createRedisKeyViewYield } from "@/lib/redis/redisKeyViewScheduler";++const props = defineProps<{ keys: readonly RedisKeyInfo[]; config: RedisKeyGrouping; separator: string; scope: string; structureRevision: number; selected: string | null; checked: ReadonlySet<string>; busy: boolean; metadataEpoch: number; treeAllowed?: boolean }>();+const emit = defineEmits<{ select: [RedisKeyInfo]; check: [RedisKeyInfo, MouseEvent]; delete: [RedisKeyInfo, MouseEvent]; copy: [RedisKeyInfo]; scroll: [Event]; resize: []; requestList: [] }>();+const { t } = useI18n();+const expanded = shallowRef(new Set<string>());+const working = ref(false);+const active = ref(true);+const scroller = ref<InstanceType<typeof RecycleScroller> | null>(null);+const outerGroups = shallowRef<readonly RedisOuterGroupBoundary[]>([]);+const headerBoundaries = shallowRef<readonly RedisHeaderBoundary[]>([]);+const publishedTree = ref(false);+const publishedExpanded = shallowRef<ReadonlySet<string>>(new Set());+const scrollTop = ref(0);+const viewportHeight = ref(0);+const rowHeight = REDIS_GROUP_ROW_HEIGHT;+let positions: { get: (id: string) => number | undefined } = { get: () => undefined };+let pendingHeaderAnchor: string | undefined;+const sticky = computed(() => {+ if (!active.value || treeBlocked.value) return [];+ return redisStickyHeaders(outerGroups.value, headerBoundaries.value, scrollTop.value, viewportHeight.value, publishedTree.value);+});+const stickyIds = computed(() => new Set(sticky.value.map((entry) => entry.row.id)));+function updateScroll() {+ scrollTop.value = Math.max(0, scroller.value?.getScroll().start ?? 0);+ viewportHeight.value = (scroller.value?.$el as HTMLElement | undefined)?.clientHeight ?? 0;+}+function onScroll(event: Event) {+ updateScroll();+ emit("scroll", event);+}+function onResize() {+ const anchor = firstUnobscuredRowIndex();+ updateScroll();+ positionRow(anchor);+ emit("resize");+}+function collapseSticky(id: string) {+ pendingHeaderAnchor = id;+ toggle(id);+}+function positionRow(position: number) {+ // Solve using the destination overlay, not the previous branch's height.+ // Fixed rows and at most three sticky slots bound this to four lookups.+ let target = position * rowHeight;+ for (let step = 0; step <= 3; step++) {+ target = Math.max(0, (position - step) * rowHeight);+ const occupied = redisStickyHeight(redisStickyHeaders(outerGroups.value, headerBoundaries.value, target, viewportHeight.value, publishedTree.value));+ if (target + occupied <= position * rowHeight) break;+ }+ const api = scroller.value;+ api?.scrollToItem(Math.floor(target / rowHeight), { align: "start" });+ api?.updateVisibleItems(true);+ updateScroll();+}+function focusHeader(id: string) {+ const element = scroller.value?.$el as HTMLElement | undefined;+ const header = Array.from(element?.querySelectorAll<HTMLElement>("[data-redis-group-header]") ?? []).find((node) => node.dataset.redisGroupHeader === id);+ header?.focus({ preventScroll: true });+}+async function navigateHeader(id: string) {+ const position = positions.get(id);+ if (position === undefined) return;+ positionRow(position);+ await nextTick();+ focusHeader(id);+}+function revealFocusedRow(event: FocusEvent) {+ const target = event.target as HTMLElement;+ const element = scroller.value?.$el as HTMLElement | undefined;+ if (!element || !sticky.value.length) return;+ const overlap = element.getBoundingClientRect().top + redisStickyHeight(sticky.value) - target.getBoundingClientRect().top;+ if (overlap > 0) {+ element.scrollTop = Math.max(0, element.scrollTop - overlap);+ updateScroll();+ }+}+const treeBlocked = computed(() => props.treeAllowed === false && props.config.inner_view === "tree");+function firstUnobscuredRowIndex() {+ const api = scroller.value;+ return api?.findItemIndex((api.getScroll().start ?? 0) + redisStickyHeight(sticky.value)) ?? 0;+}+defineExpose({+ getScrollElement: () => scroller.value?.$el as HTMLElement | undefined,+ getViewportAnchor: () => {+ const rowIndex = firstUnobscuredRowIndex();+ const row = source[rowIndex];+ return { rowIndex, keyRaw: row?.kind === "key" ? row.key.key_raw : undefined };+ },+});+let source: readonly RedisGroupedRow[] = [];+const rows = markRaw(+ new Proxy([] as RedisGroupedRow[], {+ get(target, property, receiver) {+ if (property === "length") return source.length;+ const index = typeof property === "string" && /^(0|[1-9]\d*)$/.test(property) ? Number(property) : -1;+ return index >= 0 ? source[index] : Reflect.get(target, property, receiver);+ },+ has(target, property) {+ const index = typeof property === "string" && /^(0|[1-9]\d*)$/.test(property) ? Number(property) : -1;+ return index >= 0 ? index < source.length : Reflect.has(target, property);+ },+ }),+);+let generation = 0;+let index: RedisKeyGroupIndex | null = null;+let signature = "";+let previousKeys: readonly RedisKeyInfo[] = [];+let previousScope = props.scope;++watch(+ [() => props.keys, () => props.config, () => props.scope, () => props.separator, () => props.structureRevision, expanded, active, treeBlocked],+ async () => {+ const currentGeneration = ++generation;+ if (props.scope !== previousScope || !active.value || treeBlocked.value) pendingHeaderAnchor = undefined;+ previousScope = props.scope;+ if (!active.value) return;+ if (treeBlocked.value) {+ working.value = false;+ return;+ }+ const current = () => currentGeneration === generation;+ const nextSignature = JSON.stringify([props.scope, props.separator, props.structureRevision, props.config.rules]);+ // A same-length structural replacement can rename a key anywhere, not just+ // at the tail. Reclassify it; ordinary append keeps the membership index.+ if (!index || nextSignature !== signature || !index.canAppend(props.keys) || (previousKeys !== props.keys && previousKeys.length === props.keys.length)) {+ index = new RedisKeyGroupIndex(props.config.rules, t("redisGrouping.unmatched"));+ signature = nextSignature;+ }+ previousKeys = props.keys;+ const building = index;+ working.value = true;+ // Cancellation checkpoints are cheap; only yield a browser task when this+ // build has exhausted its time budget. Nested timers can be throttled.+ const yieldControl = createRedisKeyViewYield();+ if (!(await building.append(props.keys, { current, yield: yieldControl }))) return;+ const snapshot = await building.project(props.config.inner_view, props.separator, expanded.value, { current, yield: yieldControl });+ if (!snapshot || !current()) return;+ const oldPosition = firstUnobscuredRowIndex();+ const headerAnchor = pendingHeaderAnchor;+ const anchorId = headerAnchor ?? source[oldPosition]?.id;+ const position = anchorId ? (snapshot.positions.get(anchorId) ?? Math.min(oldPosition, Math.max(0, snapshot.rows.length - 1))) : 0;+ source = snapshot.rows;+ outerGroups.value = snapshot.outerGroups;+ headerBoundaries.value = snapshot.headerBoundaries;+ positions = snapshot.positions;+ publishedTree.value = props.config.inner_view === "tree";+ publishedExpanded.value = new Set(expanded.value);+ pendingHeaderAnchor = undefined;+ positionRow(position);+ await nextTick();+ if (!current()) return;+ positionRow(position);+ if (headerAnchor) {+ await nextTick();+ if (!current()) return;+ focusHeader(headerAnchor);+ }+ working.value = false;+ },+ { immediate: true },+);++function toggle(id: string) {+ const next = new Set(expanded.value);+ if (!next.delete(id)) next.add(id);+ expanded.value = next;+}+onUnmounted(() => {+ generation++;+});+onActivated(() => {+ active.value = true;+});+onDeactivated(() => {+ active.value = false;+ generation++;+});+</script>++<template>+ <div class="flex min-h-0 flex-1 flex-col" :data-metadata-epoch="metadataEpoch">+ <div v-if="treeBlocked" role="status" class="space-y-2 p-3 text-xs text-muted-foreground">+ <p>{{ t("redisGrouping.fuzzyTreeUnavailable") }}</p>+ <Button variant="outline" size="sm" @click="emit('requestList')">{{ t("redisGrouping.useList") }}</Button>+ </div>+ <template v-else>+ <p class="shrink-0 px-2 py-1 text-xs text-muted-foreground">{{ working ? t("redisGrouping.preparing") : t("redisGrouping.loadedOnly") }}</p>+ <div class="relative flex min-h-0 flex-1 flex-col overflow-hidden" data-redis-group-viewport>+ <RecycleScroller ref="scroller" class="redis-key-scroller min-h-0 flex-1" :items="rows" :item-size="rowHeight" :buffer="600" key-field="id" @scroll="onScroll" @resize="onResize" @focusin="revealFocusedRow">+ <template #default="{ item }">+ <RedisGroupHeader+ v-if="item.kind === 'virtual-group'"+ :row="item"+ :expanded="publishedExpanded.has(item.id)"+ :data-redis-group-header="item.id"+ :class="stickyIds.has(item.id) ? 'invisible' : ''"+ :tabindex="stickyIds.has(item.id) ? -1 : 0"+ :aria-hidden="stickyIds.has(item.id) ? true : undefined"+ @toggle="toggle(item.id)"+ />+ <CustomContextMenu v-else :items="[{ label: t('redis.copyKeyName'), icon: Copy, action: () => emit('copy', item.key) }]" v-slot="{ onContextMenu }">+ <div+ class="group flex h-[30px] cursor-pointer items-center gap-1 border-b px-2 text-[13px] hover:bg-accent/40"+ :class="selected === item.key.key_raw ? 'bg-accent' : checked.has(item.key.key_raw) ? 'bg-primary/10' : ''"+ :style="{ paddingLeft: `${8 + item.depth * 10}px` }"+ @click="emit('select', item.key)"+ @contextmenu="onContextMenu"+ >+ <input type="checkbox" :checked="checked.has(item.key.key_raw)" :disabled="busy" :aria-label="item.key.key_display" @click.stop="emit('check', item.key, $event)" />+ <KeyRound class="h-3 w-3 shrink-0 text-muted-foreground" /><span class="dbx-editor-font-family min-w-0 flex-1 truncate" :title="item.key.key_display">{{ item.label || t("redisGrouping.emptyKey") }}</span>+ <span class="text-xs text-muted-foreground">{{ item.key.key_type }}</span>+ <Button variant="ghost" size="icon" class="h-5 w-5 text-destructive opacity-0 group-hover:opacity-100" :disabled="busy" :aria-label="t('redis.deleteKey')" @click.stop="emit('delete', item.key, $event)"><Trash2 class="h-3 w-3" /></Button>+ </div>+ </CustomContextMenu>+ </template>+ </RecycleScroller>+ <div v-for="(entry, slot) in sticky" :key="entry.row.id" class="absolute inset-x-0 top-0 bg-background" :style="{ transform: `translateY(${entry.top}px)`, zIndex: 20 - slot }">+ <RedisGroupHeader+ :row="entry.row"+ :expanded="publishedExpanded.has(entry.row.id)"+ :navigation="publishedTree"+ :sticky-depth="slot"+ :omitted="entry.omitted"+ :path="entry.path"+ :data-redis-sticky-group="entry.row.id"+ @toggle="collapseSticky(entry.row.id)"+ @navigate="navigateHeader(entry.row.id)"+ />+ </div>+ </div>+ </template>+ </div>+</template>diff --git a/apps/desktop/src/components/redis/RedisKeyBrowser.groupingToggle.spec.ts b/apps/desktop/src/components/redis/RedisKeyBrowser.groupingToggle.spec.tsnew file mode 100644index 0000000000..6bb637aec0--- /dev/null+++ b/apps/desktop/src/components/redis/RedisKeyBrowser.groupingToggle.spec.ts@@ -0,0 +1,11 @@+import source from "./RedisKeyBrowser.vue?raw";+import { expect, it } from "vitest";++it("uses the fuzzy toggle visual states while preserving grouping persistence and busy guards", () => {+ const button = source.match(/<Button\b[^>]*data-redis-grouping-toggle[^>]*>/s)?.[0];+ expect(button).toBeDefined();+ expect(button).toContain("customGrouping.enabled ? 'bg-accent text-accent-foreground' : 'border border-dashed border-border/70 text-muted-foreground hover:text-foreground'");+ expect(button).toContain(':aria-pressed="customGrouping.enabled"');+ expect(button).toContain(':disabled="groupingSaving || isFetchingAll"');+ expect(button).toContain("saveGrouping({ ...customGrouping, enabled: !customGrouping.enabled })");+});diff --git a/apps/desktop/src/components/redis/RedisKeyBrowser.infiniteScroll.spec.ts b/apps/desktop/src/components/redis/RedisKeyBrowser.infiniteScroll.spec.tsindex 9df3913725..2c35127fef 100644--- a/apps/desktop/src/components/redis/RedisKeyBrowser.infiniteScroll.spec.ts+++ b/apps/desktop/src/components/redis/RedisKeyBrowser.infiniteScroll.spec.ts@@ -4,8 +4,14 @@ import { createApp, defineComponent, h, KeepAlive, nextTick, ref } from "vue";import { createI18n } from "vue-i18n";import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";import type { RedisKeyInfo } from "@/lib/backend/api";+import { defaultRedisKeyGrouping, type RedisKeyGrouping } from "@/lib/redis/redisKeyGrouping";++const grouping = ref<RedisKeyGrouping>();+vi.mock("@/lib/redis/redisKeyViewScheduler", () => ({ createRedisKeyViewYield: () => () => new Promise<void>((resolve) => requestAnimationFrame(() => resolve())) }));const mocks = vi.hoisted(() => ({+ scrollerInitialSnapshot: vi.fn(),+ scrollerRefresh: vi.fn(),ensureConnected: vi.fn(),redisScanKeysBatch: vi.fn(),redisScanValues: vi.fn(),@@ -57,7 +63,10 @@ vi.mock("@/lib/backend/api", () => ({vi.mock("@/stores/connectionStore", () => ({useConnectionStore: () => ({ensureConnected: mocks.ensureConnected,- getConfig: () => ({ name: "Redis", redis_key_separator: ":", redis_scan_page_size: mocks.redisScanPageSize }),+ getConfig: () => ({ name: "Redis", redis_key_separator: ":", redis_scan_page_size: mocks.redisScanPageSize, redis_key_grouping: grouping.value }),+ updateRedisKeyGrouping: async (_id: string, config: RedisKeyGrouping) => {+ grouping.value = config;+ },updateRedisDbKeyStats: mocks.updateRedisDbKeyStats,listRedisCompletionCommandDocs: mocks.listRedisCompletionCommandDocs,listRedisCompletionKeys: mocks.listRedisCompletionKeys,@@ -238,17 +247,32 @@ vi.mock("vue-virtual-scroller", async () => {RecycleScroller: defineComponent({inheritAttrs: false,props: { items: { type: Array, default: () => [] } },- setup(props, { attrs, slots }) {+ setup(props, { attrs, slots, expose }) {+ // The installed library copies/keys all initial items in setup, even+ // though its rendered pool only contains the visible viewport.+ mocks.scrollerInitialSnapshot(props.items.slice().length);+ const epoch = ref(0);+ expose({+ findItemIndex: () => 0,+ getScroll: () => ({ start: 0 }),+ scrollToItem: () => {},+ updateVisibleItems: () => {+ mocks.scrollerRefresh(props.items.length);+ epoch.value++;+ },+ });// Real RecycleScroller only mounts as many rows as fit the viewport;// rendering everything here would defeat the point of this test, so// cap it the same way the expiry spec's mock does.const visibleItemCount = 50;- return () =>- h(+ return () => {+ void epoch.value;+ return h("div",attrs,props.items.slice(0, visibleItemCount).map((item) => slots.default?.({ item })),);+ };},}),};@@ -378,6 +402,7 @@ function restoreViewportStub() {}beforeEach(() => {+ grouping.value = undefined;resetApiMocks();});@@ -390,6 +415,124 @@ afterEach(() => {});describe("RedisKeyBrowser infinite scroll auto-continue (issue #6022)", () => {+ it.each(["mount", "refresh"])("cancels legacy publication when grouping is re-enabled during %s", async (phase) => {+ grouping.value = { ...defaultRedisKeyGrouping(), enabled: true };+ mocks.redisScanKeysBatch.mockResolvedValueOnce({ cursor: 0, keys: [{ key_display: "a", key_raw: btoa("a"), key_type: "string", ttl: -1 }], total_keys: 1 });+ const host = mountBrowser();+ await settleThoroughly();+ const reenable = () => {+ grouping.value = { ...grouping.value!, enabled: true };+ };+ if (phase === "mount") mocks.scrollerInitialSnapshot.mockImplementationOnce(reenable);+ else mocks.scrollerRefresh.mockImplementationOnce(reenable);+ grouping.value = { ...grouping.value!, enabled: false };+ await settleThoroughly();+ expect(grouping.value.enabled).toBe(true);+ expect(host.querySelector('[role="button"]')).not.toBeNull();+ expect(host.textContent).not.toContain("redisGrouping.preparingLegacy");+ expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(1);+ });++ it("does not publish a prepared old scope after the database changes or keys are cleared", async () => {+ grouping.value = { ...defaultRedisKeyGrouping(), enabled: true };+ const keys = Array.from({ length: 1100 }, (_, i) => ({ key_display: `old:${i}`, key_raw: btoa(`old:${i}`), key_type: "string", ttl: -1 }));+ mocks.redisScanKeysBatch.mockResolvedValueOnce({ cursor: 0, keys, total_keys: keys.length });+ const db = ref(0);+ const host = document.createElement("div");+ document.body.append(host);+ const app = createApp(defineComponent({ setup: () => () => h(RedisKeyBrowser, { connectionId: "connection", db: db.value, blockDangerousRedisCommands: false }) }));+ app.use(createI18n({ legacy: false, locale: "en", messages: { en: {} }, missingWarn: false, fallbackWarn: false }));+ app.mount(host);+ mountedApps.push({ unmount: () => app.unmount(), host });+ await new Promise((resolve) => setTimeout(resolve, 20));+ await settleThoroughly();+ const frames: FrameRequestCallback[] = [];+ vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => {+ frames.push(callback);+ return frames.length;+ });+ try {+ grouping.value = { ...grouping.value!, enabled: false };+ await settle();+ expect(frames.length).toBeGreaterThan(0);+ mocks.redisScanKeysBatch.mockResolvedValueOnce({ cursor: 0, keys: [{ key_display: "new", key_raw: btoa("new"), key_type: "string", ttl: -1 }], total_keys: 1 });+ db.value = 1;+ await settleThoroughly();+ for (let i = 0; i < 30; i++) {+ for (const callback of frames.splice(0)) callback(i);+ await settle();+ }+ expect(host.querySelector(`[data-redis-leaf='${btoa("new")}']`)).not.toBeNull();+ expect(host.textContent).not.toContain("old");+ window.dispatchEvent(new CustomEvent("dbx-redis-db-flushed", { detail: { connectionId: "connection", db: 1 } }));+ await settleThoroughly();+ expect(host.querySelector(`[data-redis-leaf='${btoa("new")}']`)).toBeNull();+ } finally {+ vi.unstubAllGlobals();+ }+ });++ it("keeps custom rows during cooperative legacy preparation, cancels and retries", async () => {+ grouping.value = { ...defaultRedisKeyGrouping(), enabled: true };+ const keys = Array.from({ length: 1100 }, (_, i) => ({ key_display: `namespace:${i}`, key_raw: btoa(`namespace:${i}`), key_type: "string", ttl: -1 }));+ mocks.redisScanKeysBatch.mockResolvedValueOnce({ cursor: 0, keys, total_keys: keys.length });+ const host = mountBrowser();+ await settleThoroughly();+ await new Promise((resolve) => setTimeout(resolve, 20));+ await settleThoroughly();+ expect(host.querySelector('[role="button"]')).not.toBeNull();+ const frames: FrameRequestCallback[] = [];+ vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => {+ frames.push(callback);+ return frames.length;+ });+ try {+ grouping.value = { ...grouping.value!, enabled: false };+ await settle();+ expect(frames.length).toBeGreaterThan(0);+ expect(host.textContent).toContain("redisGrouping.preparingLegacy");+ expect(host.querySelector('[role="button"]')).not.toBeNull();+ grouping.value = { ...grouping.value!, enabled: true };+ for (const callback of frames.splice(0)) callback(0);+ await settle();+ expect(host.textContent).not.toContain("redisGrouping.preparingLegacy");+ expect(host.querySelector('[role="button"]')).not.toBeNull();+ mocks.scrollerInitialSnapshot.mockClear();+ grouping.value = { ...grouping.value!, enabled: false };+ for (let i = 0; i < 30; i++) {+ for (const callback of frames.splice(0)) callback(i);+ await settle();+ }+ expect(host.textContent).not.toContain("redisGrouping.preparingLegacy");+ expect(host.querySelector("[data-redis-group]")).not.toBeNull();+ expect(mocks.scrollerInitialSnapshot).toHaveBeenCalledWith(0);+ expect(mocks.scrollerInitialSnapshot.mock.calls.every(([length]) => length === 0)).toBe(true);+ expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(1);+ } finally {+ vi.unstubAllGlobals();+ }+ });++ it("continues sparse custom groups and preserves explicit checks across layout toggles", async () => {+ grouping.value = { ...defaultRedisKeyGrouping(), enabled: true };+ stubNonOverflowingViewport();+ mocks.redisScanKeysBatch.mockResolvedValueOnce({ cursor: 7, keys: [{ key_display: "a", key_raw: btoa("a"), key_type: "string", ttl: -1 }], total_keys: 2 });+ mocks.redisScanKeysBatch.mockResolvedValueOnce({ cursor: 0, keys: [{ key_display: "b", key_raw: btoa("b"), key_type: "string", ttl: -1 }], total_keys: 2 });+ const host = mountBrowser();+ await settleThoroughly();+ expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(2);+ host.querySelector<HTMLButtonElement>("[data-redis-select-all]")!.click();+ await settleThoroughly();+ expect(host.querySelector("[data-redis-batch-delete]")?.textContent).toContain("2");+ grouping.value = { ...grouping.value!, enabled: false };+ await settleThoroughly();+ expect(host.querySelector("[data-redis-batch-delete]")?.textContent).toContain("2");+ grouping.value = { ...grouping.value!, enabled: true, inner_view: "tree" };+ await settleThoroughly();+ expect(host.querySelector("[data-redis-batch-delete]")?.textContent).toContain("2");+ expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(2);+ });+it("keeps fetching pages on its own when the loaded rows don't overflow the viewport, without any scroll event", async () => {stubNonOverflowingViewport();diff --git a/apps/desktop/src/components/redis/RedisKeyBrowser.vue b/apps/desktop/src/components/redis/RedisKeyBrowser.vueindex 4ef5911ad1..1b4fda05a3 100644--- a/apps/desktop/src/components/redis/RedisKeyBrowser.vue+++ b/apps/desktop/src/components/redis/RedisKeyBrowser.vue@@ -21,6 +21,9 @@ import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";import RedisValueViewer from "./RedisValueViewer.vue";import RedisPubSubPanel from "./RedisPubSubPanel.vue";import RedisSlowlogPanel from "./RedisSlowlogPanel.vue";+import RedisGroupedKeyList from "./RedisGroupedKeyList.vue";+import RedisKeyGroupingDialog from "./RedisKeyGroupingDialog.vue";+import { defaultRedisKeyGrouping, type RedisKeyGrouping } from "@/lib/redis/redisKeyGrouping";import * as api from "@/lib/backend/api";import type { RedisKeyInfo, RedisScanResult, RedisValue, HistoryEntry } from "@/lib/backend/api";import { uuid } from "@/lib/common/utils";@@ -65,10 +68,34 @@ import { applyRedisExpiryPolicy, type RedisExpiryMode, validateRedisExpiry } froimport { shouldLoadMoreRedisKeys } from "@/lib/redis/redisKeyInfiniteScroll";import { formatTtl } from "@/lib/common/ttlFormat";import { computeTtlCountdownValue } from "@/lib/redis/redisAutoRefresh";+import { createRedisKeyViewYield } from "@/lib/redis/redisKeyViewScheduler";const { t, locale } = useI18n();const { toast } = useToast();const connectionStore = useConnectionStore();+const customGrouping = computed(() => connectionStore.getConfig(props.connectionId)?.redis_key_grouping ?? defaultRedisKeyGrouping());+const groupingDialogOpen = ref(false);+const groupingSaving = ref(false);+const groupingError = ref("");+const groupingStructureRevision = ref(0);+const legacyGroupingPreparing = ref(false);+let legacyGroupingPublishing = false;+const showCustomGrouping = computed(() => customGrouping.value.enabled || legacyGroupingPreparing.value);+let legacyGroupingGeneration = 0;+let legacyExpandedBeforeGrouping: ReadonlySet<string> = new Set();+async function saveGrouping(config: RedisKeyGrouping) {+ if (groupingSaving.value) return;+ groupingSaving.value = true;+ groupingError.value = "";+ try {+ await connectionStore.updateRedisKeyGrouping(props.connectionId, config);+ groupingDialogOpen.value = false;+ } catch (error) {+ groupingError.value = errorMessage(error);+ } finally {+ groupingSaving.value = false;+ }+}const settingsStore = useSettingsStore();const editorFontFamilyStyle = useEditorFontFamilyStyle();@@ -113,6 +140,7 @@ const fetchAllLoadedCount = ref(0);const rootRef = ref<HTMLElement>();const keyPaneRef = ref<HTMLElement>();const redisKeyScrollerRef = ref<InstanceType<typeof RecycleScroller> | null>(null);+const groupedKeyListRef = ref<InstanceType<typeof RedisGroupedKeyList> | null>(null);let redisKeyScrollRevision = 0;let latestRedisKeyScrollAnchor: RedisKeyViewportAnchor | null = null;const valueViewerRef = ref<{ focusSearch: () => boolean } | null>(null);@@ -252,12 +280,12 @@ const isSearchMode = computed(() => (searchMode.value === "key" ? effectivePatte// opts into the namespace hierarchy that users need for group selection.const isFuzzyKeySearch = computed(() => searchMode.value === "key" && isSearchMode.value && fuzzyKeySearch.value);const fuzzyTreeLimitReached = computed(() => isFuzzyKeySearch.value && !canBuildRedisFuzzyTree(flatKeys.value.length));-const useFlatKeySearchRows = computed(() => (searchMode.value === "key" && isSearchMode.value && !fuzzyKeySearch.value) || fuzzyTreeLimitReached.value);+const useFlatKeySearchRows = computed(() => showCustomGrouping.value || (searchMode.value === "key" && isSearchMode.value && !fuzzyKeySearch.value) || fuzzyTreeLimitReached.value);const isFuzzyHierarchyView = computed(() => isFuzzyKeySearch.value && !fuzzyTreeLimitReached.value);const selectionBusy = computed(() => deletingKeys.value || loading.value || loadingMore.value || isFetchingAll.value || searchPending.value);// checkedKeys is always a subset of loaded keys, so size equality is enough.const allLoadedKeysSelected = computed(() => flatKeys.value.length > 0 && checkedKeys.value.size === flatKeys.value.length);-const allKeysSelected = computed(() => allLoadedKeysSelected.value && !hasMore.value);+const allKeysSelected = computed(() => (customGrouping.value.enabled ? filteredFlatKeys.value.length > 0 && checkedKeys.value.size === filteredFlatKeys.value.length : allLoadedKeysSelected.value && !hasMore.value));const searchPlaceholder = computed(() => {if (searchMode.value === "key") return fuzzyKeySearch.value ? t("redis.fuzzyPattern") : t("redis.pattern");return searchMode.value === "all" ? t("redis.allSearchPlaceholder") : t("redis.valueSearchPlaceholder");@@ -415,6 +443,9 @@ watch(activeCreateKeyTypeHelp, () => {void updateCreateKeyTypeHelpOffset();});const regularVisibleRows = computed(() => {+ // Prepared snapshots already own their rows. Even a watcher whose callback+ // ignores them would otherwise synchronously re-map/flatten the keyspace.+ if (showCustomGrouping.value || fetchAllVisibleRowsActive.value) return [];return useFlatKeySearchRows.value ? filteredFlatKeys.value.map((key) => redisKeyToFlatTreeRow(key, props.db)) : flattenVisibleRedisKeyTree(filteredTreeKeys.value, expandedGroupIds.value);});let fetchAllVisibleRowsSource: readonly RedisKeyTreeRow[] = [];@@ -545,6 +576,7 @@ function appendFlatKeyRecords(keys: readonly RedisKeyInfo[]) {}function replaceFlatKeyRecords(keys: RedisKeyInfo[]) {+ groupingStructureRevision.value++;flatKeyByRaw.clear();for (const key of keys) flatKeyByRaw.set(key.key_raw, key);flatKeys.value = keys;@@ -662,7 +694,7 @@ function toggleNodeCheck(node: RedisKeyTreeNode, event: MouseEvent) {if (selectionBusy.value) return;focusKeyPane();- if (event.shiftKey) {+ if (event.shiftKey && !customGrouping.value.enabled) {const rows = visibleRows.value;const to = rows.findIndex((row) => row.node.id === node.id);if (to < 0) return;@@ -682,11 +714,15 @@ function toggleNodeCheck(node: RedisKeyTreeNode, event: MouseEvent) {function selectAllLoadedKeys() {if (selectionBusy.value || loadedKeyRaws.size === 0) return;focusKeyPane();- setKeysChecked(loadedKeyRaws, true);+ setKeysChecked(customGrouping.value.enabled ? filteredFlatKeys.value.map((key) => key.key_raw) : loadedKeyRaws, true);selectionAnchorRowId.value = visibleRows.value[0]?.id ?? null;}async function selectAllKeys() {+ if (customGrouping.value.enabled) {+ selectAllLoadedKeys();+ return;+ }if (selectionBusy.value || (loadedKeyRaws.size === 0 && !hasMore.value)) return;const requestId = searchRequestId;if (hasMore.value) {@@ -1037,7 +1073,7 @@ async function maybeAutoLoadMoreRedisKeys() {// operation is spent, independent of how many (if any) new keys prior calls// yielded.if (autoLoadBudget.remaining <= 0) return;- const scroller = redisKeyScrollerRef.value?.$el as HTMLElement | undefined;+ const scroller = showCustomGrouping.value ? groupedKeyListRef.value?.getScrollElement() : (redisKeyScrollerRef.value?.$el as HTMLElement | undefined);if (!scroller) return;const shouldLoad = shouldLoadMoreRedisKeys({enabled: redisInfiniteScrollEnabled.value,@@ -1253,7 +1289,7 @@ async function fetchAll(): Promise<boolean> {let published = !changed && !fetchAllStopRequested.value;try {if (changed) {- snapshotConfig.flatRows = (searchMode.value === "key" && isSearchMode.value && !fuzzyKeySearch.value) || (isFuzzyKeySearch.value && !canBuildRedisFuzzyTree(initialFlatKeys.length + bufferedKeys.length));+ snapshotConfig.flatRows = customGrouping.value.enabled || (searchMode.value === "key" && isSearchMode.value && !fuzzyKeySearch.value) || (isFuzzyKeySearch.value && !canBuildRedisFuzzyTree(initialFlatKeys.length + bufferedKeys.length));snapshotConfig.expandAll = isSearchMode.value;snapshotConfig.expandedGroupIds = expandedGroupIds.value;snapshotConfig.noExpiryOnly = noExpiryOnly.value;@@ -2668,6 +2704,7 @@ onMounted(async () => {onActivated(async () => {resumeRedisBrowserBackgroundWork();+ if (legacyGroupingPreparing.value || legacyGroupingPublishing) void prepareLegacyGroupingView();void autofocusSearchOnce();// Ensure the connection is still alive after reactivation (e.g. tab switch).// Retry an empty failed/interrupted load, but retain successful sparse pages.@@ -2729,11 +2766,114 @@ async function executeAiCommand(command: string): Promise<boolean> {return true;}+watch(+ () => JSON.stringify(customGrouping.value.rules),+ () => resetCheckedKeys(),+);+watch(noExpiryOnly, () => resetCheckedKeys());+async function prepareLegacyGroupingView() {+ const generation = ++legacyGroupingGeneration;+ legacyGroupingPublishing = false;+ const keys = flatKeys.value;+ const connectionId = props.connectionId;+ const db = props.db;+ const current = () => generation === legacyGroupingGeneration && !customGrouping.value.enabled && redisBrowserIsActive && props.connectionId === connectionId && props.db === db && flatKeys.value === keys;+ const yieldView = createRedisKeyViewYield();+ legacyGroupingPreparing.value = true;+ const snapshot = await buildRedisKeySnapshotCooperatively(+ [keys],+ {+ db,+ separator: redisKeySeparator.value,+ flatRows: (searchMode.value === "key" && isSearchMode.value && !fuzzyKeySearch.value) || fuzzyTreeLimitReached.value,+ expandAll: false,+ expandedGroupIds: legacyExpandedBeforeGrouping,+ noExpiryOnly: noExpiryOnly.value,+ },+ { workChunkSize: 512, shouldContinue: current, yieldControl: yieldView },+ );+ if (!snapshot || !current()) return;+ let anchor = groupedKeyListRef.value?.getViewportAnchor();+ let rowIndex = Math.min(anchor?.rowIndex ?? 0, Math.max(0, snapshot.visibleRows.length - 1));+ if (anchor?.keyRaw) {+ for (let offset = 0; offset < snapshot.visibleRows.length; ) {+ if (!current()) return;+ const end = Math.min(offset + 512, snapshot.visibleRows.length);+ let found = false;+ for (; offset < end; offset++) {+ const row = snapshot.visibleRows[offset]!;+ if (row.node.kind === "leaf" && row.node.keyRaw === anchor.keyRaw) {+ rowIndex = offset;+ found = true;+ break;+ }+ }+ if (found) break;+ if (offset < snapshot.visibleRows.length) await yieldView();+ const latest = groupedKeyListRef.value?.getViewportAnchor();+ if (latest?.keyRaw !== anchor.keyRaw) {+ anchor = latest;+ rowIndex = Math.min(latest?.rowIndex ?? 0, Math.max(0, snapshot.visibleRows.length - 1));+ if (!anchor?.keyRaw) break;+ offset = 0;+ }+ }+ }+ if (!current()) return;+ // Keep the complete custom view mounted until all expensive work is done.+ // Activate prepared rows before changing structural refs, so the regular+ // projection watcher cannot accidentally rebuild this snapshot synchronously.+ fetchAllVisibleRowsActive.value = true;+ treeIndex = snapshot.treeIndex;+ treeKeys.value = snapshot.treeIndex?.root ?? [];+ expandedGroupIds.value = snapshot.expandedGroupIds;+ // RecycleScroller snapshots every initial item during setup. Mount with an+ // empty backing source, then switch the same facade before the next paint.+ fetchAllVisibleRowsSource = [];+ fetchAllFilteredKeyCount.value = snapshot.filteredKeyCount;+ refreshSelectedGroupLeafCounts();+ legacyGroupingPublishing = true;+ legacyGroupingPreparing.value = false;+ await nextTick();+ if (current()) {+ fetchAllVisibleRowsSource = snapshot.visibleRows;+ redisKeyScroller()?.scrollToItem(rowIndex, { align: "start" });+ refreshRedisKeyScroller();+ await nextTick();+ if (!current()) return;+ redisKeyScroller()?.scrollToItem(rowIndex, { align: "start" });+ refreshRedisKeyScroller();+ legacyGroupingPublishing = false;+ }+}+watch(+ () => customGrouping.value.enabled,+ (enabled, previous) => {+ if (enabled) {+ legacyGroupingGeneration++;+ legacyGroupingPublishing = false;+ if (!legacyGroupingPreparing.value) legacyExpandedBeforeGrouping = expandedGroupIds.value;+ legacyGroupingPreparing.value = false;+ rebuildTree(false);+ } else if (previous) {+ void prepareLegacyGroupingView();+ }+ },+ { flush: "sync" },+);+watch(+ [flatKeys, groupingStructureRevision, redisKeySeparator, noExpiryOnly, noExpiryProjectionEpoch, effectivePattern, () => props.connectionId, () => props.db],+ () => {+ if ((legacyGroupingPreparing.value || legacyGroupingPublishing) && !customGrouping.value.enabled) void prepareLegacyGroupingView();+ },+ { flush: "sync" },+);defineExpose({ focusSearch, insertCommand, executeCommand: executeAiCommand });</script><template><div ref="rootRef" class="h-full" :style="editorFontFamilyStyle">+ <RedisKeyGroupingDialog v-model:open="groupingDialogOpen" :config="customGrouping" :saving="groupingSaving" :error="groupingError" @save="saveGrouping" /><Splitpanes class="redis-workspace-splitpanes h-full"><!-- Key tree (left) --><Pane :size="36" :min-size="24">@@ -2754,7 +2894,17 @@ defineExpose({ focusSearch, insertCommand, executeCommand: executeAiCommand });</div><span class="redis-key-count truncate text-xs text-muted-foreground" :title="keyCountText">{{ keyCountText }}</span><div class="redis-key-toolbar-actions flex items-center justify-end gap-1">- <Button v-if="(flatKeys.length > 0 || hasMore) && !allKeysSelected" variant="ghost" size="sm" class="h-6 shrink-0 px-1.5 text-xs" :disabled="selectionBusy" :title="t('redis.selectAllLoadedTitle')" data-redis-select-all @click="selectAllKeys">{{ t("redis.selectAllLoaded") }}</Button>+ <Button+ v-if="(flatKeys.length > 0 || hasMore) && !allKeysSelected"+ variant="ghost"+ size="sm"+ class="h-6 shrink-0 px-1.5 text-xs"+ :disabled="selectionBusy"+ :title="customGrouping.enabled ? t('redisGrouping.selectLoaded') : t('redis.selectAllLoadedTitle')"+ data-redis-select-all+ @click="selectAllKeys"+ >{{ customGrouping.enabled ? t("redisGrouping.selectLoaded") : t("redis.selectAllLoaded") }}</Button+ ><Button v-if="checkedKeys.size > 0" variant="ghost" size="sm" class="h-6 shrink-0 px-1.5 text-xs" :disabled="selectionBusy" data-redis-deselect-all @click="clearAllCheckedKeys">{{ t("redis.deselectAll") }}</Button><Button v-if="checkedKeys.size > 0" variant="ghost" size="sm" class="h-6 shrink-0 text-xs text-destructive" :disabled="selectionBusy" data-redis-batch-delete @click="requestBatchDelete"><Trash2 class="w-3 h-3 mr-1" />{{ checkedKeys.size }}</Button><Button variant="ghost" size="icon" class="h-6 w-6 shrink-0" :disabled="deletingKeys || loading || loadingMore || isFetchingAll" @click="loadKeys">@@ -2833,7 +2983,48 @@ defineExpose({ focusSearch, insertCommand, executeCommand: executeAiCommand });</div></div>- <div v-if="flatKeys.length === 0 && !loading" class="flex-1 flex flex-col items-center justify-center text-muted-foreground text-xs p-4 text-center">+ <div class="flex shrink-0 flex-wrap items-center gap-1 border-b px-2 py-1">+ <Button+ variant="ghost"+ size="sm"+ class="h-6 text-xs"+ :class="customGrouping.enabled ? 'bg-accent text-accent-foreground' : 'border border-dashed border-border/70 text-muted-foreground hover:text-foreground'"+ :aria-pressed="customGrouping.enabled"+ :disabled="groupingSaving || isFetchingAll"+ data-redis-grouping-toggle+ @click="saveGrouping({ ...customGrouping, enabled: !customGrouping.enabled })"+ >{{ t("redisGrouping.toggle") }}</Button+ >+ <Button v-if="customGrouping.enabled" variant="ghost" size="sm" class="h-6 text-xs" :disabled="groupingSaving" @click="saveGrouping({ ...customGrouping, inner_view: customGrouping.inner_view === 'list' ? 'tree' : 'list' })">{{+ t(customGrouping.inner_view === "list" ? "redisGrouping.list" : "redisGrouping.tree")+ }}</Button>+ <Button variant="ghost" size="sm" class="h-6 text-xs" @click="groupingDialogOpen = true">{{ t("redisGrouping.settings") }}</Button>+ <span v-if="groupingError" role="alert" class="text-xs text-destructive">{{ groupingError }}</span>+ </div>+ <p v-if="legacyGroupingPreparing" role="status" class="shrink-0 px-2 py-1 text-xs text-muted-foreground">{{ t("redisGrouping.preparingLegacy") }}</p>+ <RedisGroupedKeyList+ v-if="showCustomGrouping"+ ref="groupedKeyListRef"+ :key="`${connectionId}:${db}`"+ :keys="filteredFlatKeys"+ :config="customGrouping"+ :separator="redisKeySeparator"+ :scope="`${connectionId}:${db}`"+ :structure-revision="groupingStructureRevision"+ :selected="selectedKeyRaw"+ :checked="checkedKeys"+ :busy="selectionBusy"+ :metadata-epoch="keyMetadataEpoch"+ :tree-allowed="!fuzzyTreeLimitReached"+ @request-list="saveGrouping({ ...customGrouping, inner_view: 'list' })"+ @scroll="onRedisKeyScroll"+ @resize="maybeAutoLoadMoreRedisKeys"+ @select="(key) => onRowClick(redisKeyToFlatTreeRow(key, db).node)"+ @check="(key, event) => toggleNodeCheck(redisKeyToFlatTreeRow(key, db).node, event)"+ @copy="(key) => copyRedisKeyName(key.key_display)"+ @delete="(key, event) => requestKeyDelete(redisKeyToFlatTreeRow(key, db).node, event)"+ />+ <div v-else-if="flatKeys.length === 0 && !loading" class="flex-1 flex flex-col items-center justify-center text-muted-foreground text-xs p-4 text-center"><template v-if="hasMore"><span class="mb-3">{{ t("redis.noKeysInScanHint") }}</span><Button variant="outline" size="sm" class="h-7 text-xs" :disabled="loadingMore || searchPending || deletingKeys" @click="loadMore()">@@ -2931,7 +3122,7 @@ defineExpose({ focusSearch, insertCommand, executeCommand: executeAiCommand });</CustomContextMenu></template></RecycleScroller>- <div v-if="fuzzyTreeLimitReached" class="shrink-0 border-t px-3 py-2 text-center text-xs text-muted-foreground">+ <div v-if="fuzzyTreeLimitReached && !showCustomGrouping" class="shrink-0 border-t px-3 py-2 text-center text-xs text-muted-foreground">{{ t("redis.fuzzyTreeLimit", { count: flatKeys.length }) }}</div><div v-if="hasMore && !isFetchingAll" class="shrink-0 border-t px-2 py-1.5 flex items-center gap-1.5">diff --git a/apps/desktop/src/components/redis/RedisKeyGroupingDialog.vue b/apps/desktop/src/components/redis/RedisKeyGroupingDialog.vuenew file mode 100644index 0000000000..a0d8826cf1--- /dev/null+++ b/apps/desktop/src/components/redis/RedisKeyGroupingDialog.vue@@ -0,0 +1,79 @@+<script setup lang="ts">+import { ref, watch } from "vue";+import { useI18n } from "vue-i18n";+import { Button } from "@/components/ui/button";+import { Input } from "@/components/ui/input";+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";+import { defaultRedisKeyGrouping, validateRedisKeyGrouping, type RedisKeyGrouping } from "@/lib/redis/redisKeyGrouping";+import { uuid } from "@/lib/common/utils";++const props = defineProps<{ open: boolean; config: RedisKeyGrouping; saving: boolean; error: string }>();+const emit = defineEmits<{ "update:open": [boolean]; save: [RedisKeyGrouping] }>();+const { t } = useI18n();+const draft = ref(defaultRedisKeyGrouping());+const invalid = ref(false);+watch(+ () => props.open,+ (open) => {+ if (open) {+ draft.value = validateRedisKeyGrouping(props.config);+ invalid.value = false;+ }+ },+);+function add(example = false) {+ draft.value.rules.push({ id: uuid(), name: example ? "Redisson" : "", enabled: true, includes: example ? ["*:redisson_options"] : ["*"], excludes: [] });+}+function move(index: number, direction: number) {+ const target = index + direction;+ if (target < 0 || target >= draft.value.rules.length) return;+ const rule = draft.value.rules.splice(index, 1)[0]!;+ draft.value.rules.splice(target, 0, rule);+}+function save() {+ try {+ emit("save", validateRedisKeyGrouping(draft.value));+ invalid.value = false;+ } catch {+ invalid.value = true;+ }+}+function patterns(event: Event): string[] {+ return (event.target as HTMLTextAreaElement).value.split("\n").filter((line) => line.length > 0);+}+</script>++<template>+ <Dialog :open="open" @update:open="emit('update:open', $event)">+ <DialogContent class="sm:max-w-2xl">+ <DialogHeader+ ><DialogTitle>{{ t("redisGrouping.settings") }}</DialogTitle></DialogHeader+ >+ <p class="text-xs text-muted-foreground">{{ t("redisGrouping.help") }}</p>+ <div class="max-h-[55vh] space-y-3 overflow-y-auto">+ <fieldset v-for="(rule, index) in draft.rules" :key="rule.id" class="space-y-2 rounded border p-3" :disabled="saving">+ <div class="flex items-center gap-2">+ <input v-model="rule.enabled" type="checkbox" :aria-label="t('redisGrouping.enabled')" />+ <Input v-model="rule.name" :placeholder="t('redisGrouping.name')" :aria-label="t('redisGrouping.name')" />+ <Button variant="outline" size="sm" :disabled="index === 0" :aria-label="t('redisGrouping.up')" @click="move(index, -1)">↑</Button>+ <Button variant="outline" size="sm" :disabled="index === draft.rules.length - 1" :aria-label="t('redisGrouping.down')" @click="move(index, 1)">↓</Button>+ <Button variant="outline" size="sm" @click="draft.rules.splice(index, 1)">{{ t("redisGrouping.remove") }}</Button>+ </div>+ <div class="grid grid-cols-2 gap-2">+ <label class="text-xs">{{ t("redisGrouping.includes") }}<textarea class="w-full rounded border bg-background p-2" :value="rule.includes.join('\n')" @input="rule.includes = patterns($event)" /></label>+ <label class="text-xs">{{ t("redisGrouping.excludes") }}<textarea class="w-full rounded border bg-background p-2" :value="rule.excludes.join('\n')" @input="rule.excludes = patterns($event)" /></label>+ </div>+ </fieldset>+ </div>+ <div class="flex gap-2">+ <Button variant="outline" :disabled="saving || draft.rules.length >= 64" @click="add()">{{ t("redisGrouping.add") }}</Button>+ <Button variant="outline" :disabled="saving || draft.rules.length >= 64" @click="add(true)">{{ t("redisGrouping.example") }}</Button>+ </div>+ <p v-if="invalid || error" role="alert" class="text-sm text-destructive">{{ error || t("redisGrouping.invalid") }}</p>+ <DialogFooter>+ <Button variant="outline" :disabled="saving" @click="emit('update:open', false)">{{ t("redisGrouping.cancel") }}</Button>+ <Button :disabled="saving" @click="save">{{ t("redisGrouping.save") }}</Button>+ </DialogFooter>+ </DialogContent>+ </Dialog>+</template>diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.tsindex a3933ab4dc..654ec509cf 100644--- a/apps/desktop/src/i18n/locales/en.ts+++ b/apps/desktop/src/i18n/locales/en.ts@@ -1,3 +1,4 @@+import { redisGroupingEn as redisGrouping } from "./redisGrouping";import docs from "./docs/en";import { consulUiMessages } from "./consulUi";import { sqlServerTraceMessages as sqlServerTrace } from "./sqlServerTraceMessages";@@ -79,6 +80,7 @@ const consul = {};export default {+ redisGrouping,customType: {kinds: {base: "Base",diff --git a/apps/desktop/src/i18n/locales/redisGrouping.ts b/apps/desktop/src/i18n/locales/redisGrouping.tsnew file mode 100644index 0000000000..a91939baa8--- /dev/null+++ b/apps/desktop/src/i18n/locales/redisGrouping.ts@@ -0,0 +1,84 @@+export const redisGroupingEn = {+ preparingLegacy: "Preparing the previous view; custom groups remain available…",+ fuzzyTreeUnavailable: "This fuzzy search exceeds the existing tree resource limit. Choose List to browse the loaded matches, or narrow the search to use Tree.",+ useList: "Use List",+ settings: "Grouping rules",+ toggle: "Custom groups",+ list: "List",+ tree: "Tree",+ help: "Connection-wide rules, first match wins. One case-sensitive Redis glob per line (*, ?, [a-z], backslash escape). Includes are OR; exclusions veto. Empty includes match all. Counts cover loaded keys only. Groups are not deletion boundaries.",+ enabled: "Enable rule",+ name: "Group name",+ up: "Move up",+ down: "Move down",+ remove: "Remove",+ includes: "Include patterns",+ excludes: "Exclude patterns",+ add: "Add rule",+ example: "Add Redisson example",+ invalid: "Enter unique rule IDs, a name and at least one pattern per rule (maximum 64 rules, 64 patterns per list, 1024 bytes per pattern).",+ cancel: "Cancel",+ save: "Save",+ unmatched: "Unmatched",+ preparing: "Updating loaded groups…",+ loadedOnly: "Groups show loaded matches only; expand does not scan Redis.",+ count: "({count} loaded)",+ emptyKey: "(empty key)",+ selectLoaded: "Select loaded matches",+};+export const redisGroupingZhCN = {+ preparingLegacy: "正在准备原有视图,期间仍可浏览自定义分组…",+ fuzzyTreeUnavailable: "当前模糊搜索超过已有树视图资源限制。请选择列表浏览已加载匹配项,或缩小搜索范围后使用前缀树。",+ useList: "使用列表",+ settings: "分组规则",+ toggle: "自定义分组",+ list: "列表",+ tree: "前缀树",+ help: "规则按连接保存,按顺序首次匹配归组。每行一个区分大小写的 Redis 通配模式(*、?、[a-z]、反斜杠转义)。包含条件任一命中即可,排除条件优先;包含为空表示全部。计数仅涵盖已加载 Key,分组不是删除边界。",+ enabled: "启用规则",+ name: "分组名称",+ up: "上移",+ down: "下移",+ remove: "移除",+ includes: "包含模式",+ excludes: "排除模式",+ add: "添加规则",+ example: "添加 Redisson 示例",+ invalid: "请填写唯一规则 ID、名称及至少一个模式(最多 64 个规则,每组包含/排除各 64 个模式,每个模式 1024 字节)。",+ cancel: "取消",+ save: "保存",+ unmatched: "未匹配",+ preparing: "正在更新已加载分组…",+ loadedOnly: "分组仅展示已加载匹配结果,展开不会扫描 Redis。",+ count: "(已加载 {count})",+ emptyKey: "(空 Key)",+ selectLoaded: "选择已加载匹配项",+};+export const redisGroupingZhTW = {+ preparingLegacy: "正在準備原有檢視,期間仍可瀏覽自訂分組…",+ fuzzyTreeUnavailable: "目前模糊搜尋超過既有樹狀檢視資源限制。請選擇列表瀏覽已載入匹配項,或縮小搜尋範圍後使用前綴樹。",+ useList: "使用列表",+ settings: "分組規則",+ toggle: "自訂分組",+ list: "列表",+ tree: "前綴樹",+ help: "規則按連線儲存,按順序首次匹配歸組。每行一個區分大小寫的 Redis 萬用模式(*、?、[a-z]、反斜線跳脫)。包含條件任一命中即可,排除條件優先;包含為空表示全部。計數僅涵蓋已載入 Key,分組不是刪除邊界。",+ enabled: "啟用規則",+ name: "分組名稱",+ up: "上移",+ down: "下移",+ remove: "移除",+ includes: "包含模式",+ excludes: "排除模式",+ add: "新增規則",+ example: "新增 Redisson 範例",+ invalid: "請填寫唯一規則 ID、名稱及至少一個模式(最多 64 個規則,每組包含/排除各 64 個模式,每個模式 1024 位元組)。",+ cancel: "取消",+ save: "儲存",+ unmatched: "未匹配",+ preparing: "正在更新已載入分組…",+ loadedOnly: "分組僅展示已載入匹配結果,展開不會掃描 Redis。",+ count: "(已載入 {count})",+ emptyKey: "(空 Key)",+ selectLoaded: "選擇已載入匹配項",+};diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.tsindex 6c7dc7149b..9570b0842b 100644--- a/apps/desktop/src/i18n/locales/zh-CN.ts+++ b/apps/desktop/src/i18n/locales/zh-CN.ts@@ -1,9 +1,11 @@+import { redisGroupingZhCN as redisGrouping } from "./redisGrouping";import { withEnglishFallback } from "./fallback";import docs from "./docs/zh-CN";import { consul } from "./consulZhCN";import { meilisearchManagementZhCN } from "./meilisearchManagement";export default withEnglishFallback({+ redisGrouping,customType: {kinds: {base: "基础类型",diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.tsindex a7cc691720..51614bf5af 100644--- a/apps/desktop/src/i18n/locales/zh-TW.ts+++ b/apps/desktop/src/i18n/locales/zh-TW.ts@@ -1,3 +1,4 @@+import { redisGroupingZhTW as redisGrouping } from "./redisGrouping";import { withEnglishFallback } from "./fallback";import { meilisearchManagementZhTW } from "./meilisearchManagement";import docs from "./docs/zh-TW";@@ -81,6 +82,7 @@ const consul = {};export default withEnglishFallback({+ redisGrouping,customType: {kinds: {base: "基礎型別",diff --git a/apps/desktop/src/lib/redis/__tests__/redisKeyGroupBoundary.spec.ts b/apps/desktop/src/lib/redis/__tests__/redisKeyGroupBoundary.spec.tsnew file mode 100644index 0000000000..4506ce0218--- /dev/null+++ b/apps/desktop/src/lib/redis/__tests__/redisKeyGroupBoundary.spec.ts@@ -0,0 +1,43 @@+import { expect, it } from "vitest";+import { RedisKeyGroupIndex, findRedisOuterGroup } from "../redisKeyGroupIndex";++const work = { current: () => true, yield: async () => {} };+const rules = [+ { id: "a", name: "A", enabled: true, includes: ["a:*"], excludes: [] },+ { id: "empty", name: "Empty", enabled: true, includes: ["missing:*"], excludes: [] },+];+const key = (name: string) => ({ key_raw: btoa(name), key_display: name, key_type: "string", ttl: -1 });++it.each(["list", "tree"] as const)("captures atomic outer boundaries for %s, excluding namespace headers", async (view) => {+ const index = new RedisKeyGroupIndex(rules, "Unmatched");+ await index.append([key("a:1"), key("a:2"), key("b:1")], work);+ const expanded = new Set(['custom:"a"', 'custom:"a":namespace:["a"]', "custom:unmatched"]);+ const first = (await index.project(view, ":", expanded, work))!;+ expect(first.outerGroups).toHaveLength(3);+ expect(first.outerGroups.map((group) => group.row.label)).toEqual(["A", "Empty", "Unmatched"]);+ for (const group of first.outerGroups) {+ expect(first.rows[group.start]).toBe(group.row);+ expect(findRedisOuterGroup(first.outerGroups, group.start)).toBe(group);+ expect(findRedisOuterGroup(first.outerGroups, group.end - 0.1)).toBe(group);+ }+ expect(findRedisOuterGroup(first.outerGroups, -1)).toBeUndefined();+ expect(findRedisOuterGroup(first.outerGroups, first.rows.length)).toBeUndefined();+ const before = first.outerGroups.map((group) => ({ ...group }));+ await index.append([key("a:1"), key("a:2"), key("b:1"), key("a:3")], work);+ const collapsed = (await index.project(view, ":", new Set(), work))!;+ expect(collapsed.outerGroups.map((group) => group.end - group.start)).toEqual([1, 1, 1]);+ expect(first.outerGroups).toEqual(before);+ expect(first.outerGroups[0]!.row.count).toBe(2);+ expect(collapsed.outerGroups[0]!.row.count).toBe(3);+});++it("keeps million-key boundary storage bounded by groups, including unmatched", async () => {+ const index = new RedisKeyGroupIndex(rules, "Unmatched");+ const keys = Array.from({ length: 1_000_000 }, (_, n) => key(`a:${n}`));+ await index.append(keys, work);+ const snapshot = (await index.project("list", ":", new Set(['custom:"a"']), work))!;+ expect(snapshot.rows.length).toBe(1_000_002);+ expect(snapshot.outerGroups).toHaveLength(2);+ expect(findRedisOuterGroup(snapshot.outerGroups, 999_999)?.row.id).toBe('custom:"a"');+ expect(findRedisOuterGroup(snapshot.outerGroups, 1_000_001)?.row.label).toBe("Empty");+});diff --git a/apps/desktop/src/lib/redis/__tests__/redisKeyGrouping.spec.ts b/apps/desktop/src/lib/redis/__tests__/redisKeyGrouping.spec.tsnew file mode 100644index 0000000000..bf9136b395--- /dev/null+++ b/apps/desktop/src/lib/redis/__tests__/redisKeyGrouping.spec.ts@@ -0,0 +1,94 @@+import { describe, expect, it } from "vitest";+import { compileRedisGroupGlob, compileRedisKeyGroups, defaultRedisKeyGrouping, validateRedisKeyGrouping } from "../redisKeyGrouping";+import { RedisKeyGroupIndex } from "../redisKeyGroupIndex";+import type { RedisKeyInfo } from "@/lib/backend/api";++const raw = (value: string) => btoa(String.fromCharCode(...new TextEncoder().encode(value)));+const key = (name: string): RedisKeyInfo => ({ key_raw: raw(name), key_display: name, key_type: "string", ttl: -1, size: 1 });+const rule = { id: "suffix", name: "Metadata", enabled: true, includes: ["*:redisson_options"], excludes: [] };+const work = { current: () => true, yield: async () => {} };++describe("Redis grouping contracts", () => {+ it("is opt-in and rejects malformed edits", () => {+ expect(validateRedisKeyGrouping(defaultRedisKeyGrouping()).enabled).toBe(false);+ expect(() => validateRedisKeyGrouping({ ...defaultRedisKeyGrouping(), rules: [{ ...rule, includes: [] }] })).toThrow();+ expect(() => validateRedisKeyGrouping({ ...defaultRedisKeyGrouping(), rules: [rule, rule] })).toThrow();+ expect(() => validateRedisKeyGrouping({ ...defaultRedisKeyGrouping(), version: 2 })).toThrow();+ });+ it("uses whole-byte glob semantics, escapes and ranges", () => {+ const matches = (pattern: string, text: string) => compileRedisGroupGlob(pattern)(new TextEncoder().encode(text));+ expect(matches("?", "中")).toBe(false);+ expect(matches("???", "中")).toBe(true);+ expect(matches("[z-a]", "q")).toBe(true);+ expect(matches("[^a]", "b")).toBe(true);+ expect(matches("a\\*", "a*")).toBe(true);+ expect(matches("a", "ab")).toBe(false);+ expect(matches("*", "")).toBe(true);+ expect(matches("**", "")).toBe(false);+ expect(compileRedisGroupGlob("?")(new Uint8Array([255]))).toBe(true);+ expect(matches("*a*a*a*a*a*b", "a".repeat(10000))).toBe(false);+ });+ it("uses first match and exclusion veto without lossy display text", () => {+ const classify = compileRedisKeyGroups([rule, { ...rule, id: "business", includes: [], excludes: ["private:*"] }]);+ expect(classify(raw("cache:redisson_options"))).toBe("suffix");+ expect(classify(raw("cache:one"))).toBe("business");+ expect(classify(raw("private:one"))).toBe(null);+ expect(compileRedisKeyGroups([{ ...rule, includes: ["?"], enabled: false }])("/w==")).toBe(null);+ });+ it("deduplicates append and exposes immutable-length range snapshots", async () => {+ const index = new RedisKeyGroupIndex([rule], "Other");+ const first = [key("a:redisson_options"), key("b")];+ await index.append(first, work);+ const expanded = new Set(['custom:"suffix"', "custom:unmatched"]);+ const before = (await index.project("list", ":", expanded, work))!;+ expect(before.rows.map((row) => row.kind)).toEqual(["virtual-group", "key", "virtual-group", "key"]);+ await index.append([...first, first[0]!, key("c")], work);+ expect(before.rows.length).toBe(4);+ const after = (await index.project("list", ":", expanded, work))!;+ expect(after.rows.length).toBe(5);+ expect(after.positions.get(`key:${raw("c")}`)).toBe(4);+ });+ it("scopes namespace IDs by outer group and never produces legacy group nodes", async () => {+ const index = new RedisKeyGroupIndex([rule], "Other");+ await index.append([key("a:redisson_options"), key("a:other")], work);+ const result = (await index.project("tree", ":", new Set(['custom:"suffix"', "custom:unmatched"]), work))!;+ expect(new Set(result.rows.map((row) => row.id)).size).toBe(result.rows.length);+ expect(result.rows.every((row) => row.kind === "virtual-group")).toBe(true);+ const expanded = new Set(result.rows.map((row) => row.id));+ const leaves = (await index.project("tree", ":", expanded, work))!;+ expect(leaves.rows.filter((row) => row.kind === "key")).toHaveLength(2);+ });+ it("cancels bounded work and resumes append without duplicates", async () => {+ const index = new RedisKeyGroupIndex([], "Other");+ const keys = Array.from({ length: 2000 }, (_, i) => key(String(i)));+ let alive = true;+ expect(+ await index.append(keys, {+ current: () => alive,+ yield: async () => {+ alive = false;+ },+ }),+ ).toBe(false);+ await index.append(keys, work);+ const result = (await index.project("list", ":", new Set(["custom:unmatched"]), work))!;+ expect(result.rows.length).toBe(2001);+ });+ it("does not materialize each loaded key again when projecting a large list", async () => {+ const index = new RedisKeyGroupIndex([], "Other");+ await index.append(+ Array.from({ length: 100000 }, (_, i) => key(String(i))),+ work,+ );+ let yields = 0;+ const result = (await index.project("list", ":", new Set(["custom:unmatched"]), {+ current: () => true,+ yield: async () => {+ yields++;+ },+ }))!;+ expect(yields).toBe(0);+ expect(result.rows.length).toBe(100001);+ expect(result.positions.get(`key:${raw("99999")}`)).toBe(100000);+ });+});diff --git a/apps/desktop/src/lib/redis/__tests__/redisKeyViewScheduler.spec.ts b/apps/desktop/src/lib/redis/__tests__/redisKeyViewScheduler.spec.tsnew file mode 100644index 0000000000..e76a5feb17--- /dev/null+++ b/apps/desktop/src/lib/redis/__tests__/redisKeyViewScheduler.spec.ts@@ -0,0 +1,42 @@+import { expect, it } from "vitest";+import { createRedisKeyViewYield } from "../redisKeyViewScheduler";+import { buildRedisKeySnapshotCooperatively } from "../redisKeyTree";++it("uses small checkpoints without paying a task/frame for every checkpoint", async () => {+ let clock = 0;+ let tasks = 0;+ const checkpoint = createRedisKeyViewYield({+ now: () => clock,+ yieldTask: async () => {+ tasks++;+ },+ budgetMs: 8,+ });+ for (let i = 0; i < 1000; i++) {+ clock += 0.125;+ await checkpoint();+ }+ expect(tasks).toBe(15);+});++it("retains builder cancellation checks before a real task is needed", async () => {+ let checks = 0;+ let tasks = 0;+ const keys = Array.from({ length: 2000 }, (_, i) => ({ key_raw: String(i), key_display: String(i), ttl: -1, key_type: "string" }));+ const result = await buildRedisKeySnapshotCooperatively(+ [keys],+ { db: 0, flatRows: true, expandAll: false, expandedGroupIds: new Set() },+ {+ workChunkSize: 512,+ shouldContinue: () => ++checks < 5,+ yieldControl: createRedisKeyViewYield({+ now: () => 0,+ yieldTask: async () => {+ tasks++;+ },+ }),+ },+ );+ expect(result).toBeNull();+ expect(tasks).toBe(0);+});diff --git a/apps/desktop/src/lib/redis/__tests__/redisStickyHeaders.spec.ts b/apps/desktop/src/lib/redis/__tests__/redisStickyHeaders.spec.tsnew file mode 100644index 0000000000..2b5819ba9a--- /dev/null+++ b/apps/desktop/src/lib/redis/__tests__/redisStickyHeaders.spec.ts@@ -0,0 +1,74 @@+import { expect, it } from "vitest";+import { findRedisHeaderChain, RedisKeyGroupIndex } from "../redisKeyGroupIndex";+import { redisStickyHeaders, redisStickyHeight } from "../redisStickyHeaders";++const work = { current: () => true, yield: async () => {} };+async function fixture() {+ const index = new RedisKeyGroupIndex([], "Unmatched");+ await index.append(+ Array.from({ length: 1000 }, (_, n) => ({ key_display: `a:b:c:d:${n}`, key_raw: btoa(`a:b:c:d:${n}`), ttl: -1, key_type: "string" })),+ work,+ );+ const expanded = new Set(["custom:unmatched"]);+ for (const path of [["a"], ["a", "b"], ["a", "b", "c"], ["a", "b", "c", "d"]]) expanded.add(`custom:unmatched:namespace:${JSON.stringify(path)}`);+ return { index, expanded, snapshot: (await index.project("tree", ":", expanded, work))! };+}++it("indexes ancestry once per header, with atomic end ranges and no leaf access during lookup", async () => {+ const { index, expanded, snapshot } = await fixture();+ expect(snapshot.headerBoundaries).toHaveLength(5);+ let reads = 0;+ const headers = new Proxy(snapshot.headerBoundaries, {+ get(target, prop, receiver) {+ if (typeof prop === "string" && /^\d+$/.test(prop)) reads++;+ return Reflect.get(target, prop, receiver);+ },+ });+ expect(findRedisHeaderChain(headers, 999).map((header) => header.row.label)).toEqual(["Unmatched", "a", "b", "c", "d"]);+ expect(reads).toBeLessThanOrEqual(5);+ expanded.delete('custom:unmatched:namespace:["a","b"]');+ const collapsed = (await index.project("tree", ":", expanded, work))!;+ expect(collapsed.headerBoundaries).toHaveLength(3);+ expect(snapshot.headerBoundaries[0]!.end).toBe(1005);+ expect(findRedisHeaderChain(collapsed.headerBoundaries, 3)).toEqual([]);+});++it("bounds height at zero, one, two and three rows and indicates omitted ancestors", async () => {+ const { snapshot } = await fixture();+ const sticky = (height: number, scroll = 500) => redisStickyHeaders(snapshot.outerGroups, snapshot.headerBoundaries, scroll, height, true);+ expect(sticky(99)).toEqual([]);+ expect(sticky(100).map((entry) => entry.row.label)).toEqual(["Unmatched"]);+ expect(sticky(200).map((entry) => entry.row.label)).toEqual(["Unmatched", "d"]);+ expect(sticky(300).map((entry) => entry.row.label)).toEqual(["Unmatched", "c", "d"]);+ expect(sticky(300)[1]!.omitted).toBe(true);+ expect(sticky(300)[1]!.path).toBe("Unmatched › a › b › c › d");+ expect(redisStickyHeight(sticky(1000))).toBe(90);+ expect(sticky(300, 0)).toEqual([]);+ expect(redisStickyHeaders(snapshot.outerGroups, snapshot.headerBoundaries, 500, 99, false)).toHaveLength(1);+});++it("retains expanded parents above a collapsed current namespace before compressing", async () => {+ const { index, expanded } = await fixture();+ expanded.delete('custom:unmatched:namespace:["a","b","c","d"]');+ const snapshot = (await index.project("tree", ":", expanded, work))!;+ expect(redisStickyHeaders(snapshot.outerGroups, snapshot.headerBoundaries, 60, 300, true).map((entry) => entry.row.label)).toEqual(["Unmatched", "b", "c"]);+});++it("pushes the outgoing sibling behind its parents and never pins the incoming natural header twice", async () => {+ const index = new RedisKeyGroupIndex([], "Unmatched");+ await index.append(+ ["a", "b"].flatMap((branch) => Array.from({ length: 10 }, (_, n) => ({ key_display: `p:${branch}:${n}`, key_raw: btoa(`p:${branch}:${n}`), ttl: -1, key_type: "string" }))),+ work,+ );+ const expanded = new Set(["custom:unmatched", 'custom:unmatched:namespace:["p"]', 'custom:unmatched:namespace:["p","a"]', 'custom:unmatched:namespace:["p","b"]']);+ const snapshot = (await index.project("tree", ":", expanded, work))!;+ const b = snapshot.headerBoundaries.find((header) => header.row.label === "b")!;+ const before = redisStickyHeaders(snapshot.outerGroups, snapshot.headerBoundaries, b.start * 30 - 75, 300, true);+ expect(before.map((entry) => entry.row.label)).toEqual(["Unmatched", "p", "a"]);+ expect(before[2]!.top).toBe(45);+ expect(redisStickyHeight(before)).toBe(75);+ const aligned = redisStickyHeaders(snapshot.outerGroups, snapshot.headerBoundaries, b.start * 30 - 60, 300, true);+ expect(aligned.map((entry) => entry.row.label)).toEqual(["Unmatched", "p"]);+ const after = redisStickyHeaders(snapshot.outerGroups, snapshot.headerBoundaries, b.start * 30 - 59, 300, true);+ expect(after.map((entry) => entry.row.label)).toEqual(["Unmatched", "p", "b"]);+});diff --git a/apps/desktop/src/lib/redis/redisKeyGroupIndex.ts b/apps/desktop/src/lib/redis/redisKeyGroupIndex.tsnew file mode 100644index 0000000000..ba489e3a5a--- /dev/null+++ b/apps/desktop/src/lib/redis/redisKeyGroupIndex.ts@@ -0,0 +1,255 @@+import type { RedisKeyInfo } from "@/lib/backend/api";+import { compileRedisKeyGroups, type RedisKeyGroupRule } from "./redisKeyGrouping";++export interface RedisVirtualGroupRow {+ kind: "virtual-group";+ id: string;+ label: string;+ depth: number;+ count: number;+}+export interface RedisGroupedKeyRow {+ kind: "key";+ id: string;+ key: RedisKeyInfo;+ label: string;+ depth: number;+}+export type RedisGroupedRow = RedisVirtualGroupRow | RedisGroupedKeyRow;+export interface RedisOuterGroupBoundary {+ start: number;+ end: number;+ row: RedisVirtualGroupRow;+}+export interface RedisHeaderBoundary extends RedisOuterGroupBoundary {+ parent?: RedisHeaderBoundary;+}++/** Header-only binary lookup plus parent links; never reads leaf rows. */+export function findRedisHeaderChain(headers: readonly RedisHeaderBoundary[], position: number): RedisHeaderBoundary[] {+ let low = 0;+ let high = headers.length;+ while (low < high) {+ const mid = (low + high) >>> 1;+ if (headers[mid]!.start <= position) low = mid + 1;+ else high = mid;+ }+ let header: RedisHeaderBoundary | undefined = headers[low - 1];+ const chain: RedisHeaderBoundary[] = [];+ while (header) {+ if (position < header.end) chain.push(header);+ header = header.parent;+ }+ return chain.reverse();+}++/** Only searches outer sections (at most 65), never the virtual key source. */+export function findRedisOuterGroup(groups: readonly RedisOuterGroupBoundary[], position: number): RedisOuterGroupBoundary | undefined {+ let low = 0;+ let high = groups.length - 1;+ while (low <= high) {+ const mid = (low + high) >>> 1;+ const group = groups[mid]!;+ if (position < group.start) high = mid - 1;+ else if (position >= group.end) low = mid + 1;+ else return group;+ }+ return undefined;+}+interface Namespace {+ id: string;+ label: string;+ count: number;+ children: Map<string, Namespace>;+ keys: RedisKeyInfo[];+}+interface Group {+ id: string;+ label: string;+ keys: RedisKeyInfo[];+ tree?: Namespace;+ treeLength: number;+}+export interface GroupWork {+ current: () => boolean;+ yield: () => Promise<void>;+}+const CHUNK = 512;++/** Non-reactive index: ordinary append batches classify only new identities. */+export class RedisKeyGroupIndex {+ readonly groups: Group[];+ private readonly classify: ReturnType<typeof compileRedisKeyGroups>;+ private readonly byId = new Map<string | null, Group>();+ private readonly locations = new Map<string, { group: Group; offset: number; namespace?: Namespace; namespaceOffset?: number }>();+ private consumed = 0;+ private lastRaw: string | undefined;++ constructor(rules: readonly RedisKeyGroupRule[], unmatched: string) {+ this.classify = compileRedisKeyGroups(rules);+ this.groups = rules+ .filter((rule) => rule.enabled)+ .map((rule) => {+ const group = { id: `custom:${JSON.stringify(rule.id)}`, label: rule.name, keys: [], treeLength: 0 };+ this.byId.set(rule.id, group);+ return group;+ });+ const group = { id: "custom:unmatched", label: unmatched, keys: [], treeLength: 0 };+ this.byId.set(null, group);+ this.groups.push(group);+ }++ canAppend(keys: readonly RedisKeyInfo[]): boolean {+ return keys.length >= this.consumed && (!this.consumed || keys[this.consumed - 1]?.key_raw === this.lastRaw);+ }++ async append(keys: readonly RedisKeyInfo[], work: GroupWork): Promise<boolean> {+ for (let offset = this.consumed; offset < keys.length; ) {+ if (!work.current()) return false;+ const end = Math.min(offset + CHUNK, keys.length);+ for (; offset < end; offset++) {+ const key = keys[offset]!;+ if (this.locations.has(key.key_raw)) continue;+ const group = this.byId.get(this.classify(key.key_raw))!;+ this.locations.set(key.key_raw, { group, offset: group.keys.length });+ group.keys.push(key);+ }+ this.consumed = offset;+ this.lastRaw = keys[offset - 1]?.key_raw;+ if (offset < keys.length) await work.yield();+ }+ return work.current();+ }++ async project(view: "list" | "tree", separator: string, expanded: ReadonlySet<string>, work: GroupWork): Promise<{ rows: RedisGroupedRow[]; outerGroups: RedisOuterGroupBoundary[]; headerBoundaries: RedisHeaderBoundary[]; positions: { get: (id: string) => number | undefined } } | null> {+ // Row ranges reference canonical key arrays. A million-key list projection+ // is O(groups), not O(keys) per incoming batch, and only mounted leaves+ // allocate presentation objects. Captured lengths make publication atomic.+ const ranges: { start: number; length: number; row?: RedisVirtualGroupRow; keys?: readonly RedisKeyInfo[]; depth: number }[] = [];+ const headers = new Map<string, number>();+ const outerGroups: RedisOuterGroupBoundary[] = [];+ const headerBoundaries: RedisHeaderBoundary[] = [];+ const openHeaders: RedisHeaderBoundary[] = [];+ const keyRanges = new Map<string, number>();+ let length = 0;+ let units = 0;+ const checkpoint = async () => {+ if (++units % CHUNK === 0) await work.yield();+ return work.current();+ };+ const add = (row: RedisVirtualGroupRow) => {+ while (openHeaders.length && openHeaders[openHeaders.length - 1]!.row.depth >= row.depth) openHeaders.pop()!.end = length;+ const boundary = { start: length, end: length + 1, row, parent: openHeaders[openHeaders.length - 1] };+ headerBoundaries.push(boundary);+ openHeaders.push(boundary);+ headers.set(row.id, length);+ ranges.push({ start: length++, length: 1, row, depth: row.depth });+ };+ const addKeys = (id: string, keys: readonly RedisKeyInfo[], depth: number) => {+ keyRanges.set(id, length);+ if (keys.length) ranges.push({ start: length, length: keys.length, keys, depth });+ length += keys.length;+ };+ const leaf = (key: RedisKeyInfo, label: string, depth: number): RedisGroupedKeyRow => ({ kind: "key", id: `key:${key.key_raw}`, key, label, depth });+ for (const group of this.groups) {+ if (!work.current()) return null;+ if (group.id === "custom:unmatched" && !group.keys.length) continue;+ const previous = outerGroups[outerGroups.length - 1];+ if (previous) previous.end = length;+ const row: RedisVirtualGroupRow = { kind: "virtual-group", id: group.id, label: group.label, depth: 0, count: group.keys.length };+ outerGroups.push({ start: length, end: length + 1, row });+ add(row);+ if (!expanded.has(group.id)) continue;+ if (view === "list" || !separator) {+ addKeys(group.id, group.keys, 1);+ } else {+ // A namespace index is built only for an expanded outer group. It holds+ // references to canonical records, not copies of metadata.+ group.tree ??= { id: group.id, label: "", count: 0, children: new Map(), keys: [] };+ for (let i = group.treeLength; i < group.keys.length; i++) {+ const key = group.keys[i]!;+ const parts = key.key_display.split(separator);+ let node = group.tree;+ const path: string[] = [];+ node.count++;+ for (const part of parts.slice(0, -1)) {+ path.push(part);+ let child = node.children.get(part);+ if (!child) {+ child = { id: `${group.id}:namespace:${JSON.stringify(path)}`, label: part, count: 0, children: new Map(), keys: [] };+ node.children.set(part, child);+ }+ child.count++;+ node = child;+ }+ const location = this.locations.get(key.key_raw)!;+ location.namespace = node;+ location.namespaceOffset = node.keys.length;+ node.keys.push(key);+ group.treeLength = i + 1;+ if (!(await checkpoint())) return null;+ }+ const stack: { children: Iterator<Namespace>; depth: number }[] = [{ children: group.tree.children.values(), depth: 1 }];+ addKeys(group.tree.id, group.tree.keys, 1);+ while (stack.length) {+ const frame = stack[stack.length - 1]!;+ const result = frame.children.next();+ if (result.done) {+ stack.pop();+ continue;+ }+ const node = result.value;+ add({ kind: "virtual-group", id: node.id, label: node.label, depth: frame.depth, count: node.count });+ if (expanded.has(node.id)) {+ addKeys(node.id, node.keys, frame.depth + 1);+ stack.push({ children: node.children.values(), depth: frame.depth + 1 });+ }+ if (!(await checkpoint())) return null;+ }+ }+ }+ const lastGroup = outerGroups[outerGroups.length - 1];+ if (lastGroup) lastGroup.end = length;+ for (const header of openHeaders) header.end = length;+ const at = (index: number): RedisGroupedRow | undefined => {+ if (index < 0 || index >= length) return undefined;+ let low = 0;+ let high = ranges.length - 1;+ while (low <= high) {+ const mid = (low + high) >>> 1;+ const range = ranges[mid]!;+ if (index < range.start) high = mid - 1;+ else if (index >= range.start + range.length) low = mid + 1;+ else {+ if (range.row) return range.row;+ const key = range.keys![index - range.start]!;+ const parts = view === "tree" && separator ? key.key_display.split(separator) : [key.key_display];+ return leaf(key, parts[parts.length - 1] ?? "", range.depth);+ }+ }+ return undefined;+ };+ const rows = new Proxy([] as RedisGroupedRow[], {+ get(target, property, receiver) {+ if (property === "length") return length;+ const n = typeof property === "string" && /^(0|[1-9]\d*)$/.test(property) ? Number(property) : -1;+ return n >= 0 ? at(n) : Reflect.get(target, property, receiver);+ },+ has(target, property) {+ const n = typeof property === "string" && /^(0|[1-9]\d*)$/.test(property) ? Number(property) : -1;+ return n >= 0 ? n < length : Reflect.has(target, property);+ },+ });+ const positions = {+ get: (id: string) => {+ if (!id.startsWith("key:")) return headers.get(id);+ const location = this.locations.get(id.slice(4));+ if (!location) return undefined;+ const tree = view === "tree" && !!separator;+ const start = keyRanges.get(tree ? (location.namespace?.id ?? "") : location.group.id);+ return start === undefined ? undefined : start + (tree ? location.namespaceOffset! : location.offset);+ },+ };+ return work.current() ? { rows, outerGroups, headerBoundaries, positions } : null;+ }+}diff --git a/apps/desktop/src/lib/redis/redisKeyGrouping.ts b/apps/desktop/src/lib/redis/redisKeyGrouping.tsnew file mode 100644index 0000000000..940cfb90aa--- /dev/null+++ b/apps/desktop/src/lib/redis/redisKeyGrouping.ts@@ -0,0 +1,109 @@+/** Connection-persisted rules. Classification never changes Redis keys or SCAN. */+export interface RedisKeyGroupRule {+ id: string;+ name: string;+ enabled: boolean;+ includes: string[];+ excludes: string[];+}++export interface RedisKeyGrouping {+ version: 1;+ enabled: boolean;+ inner_view: "list" | "tree";+ rules: RedisKeyGroupRule[];+}++export function defaultRedisKeyGrouping(): RedisKeyGrouping {+ return { version: 1, enabled: false, inner_view: "list", rules: [] };+}++/** Reject invalid edits/imports rather than silently discarding saved rules. */+export function validateRedisKeyGrouping(value: unknown): RedisKeyGrouping {+ if (!value || typeof value !== "object") throw new Error("Invalid Redis grouping configuration");+ const config = value as Partial<RedisKeyGrouping>;+ if (config.version !== 1 || typeof config.enabled !== "boolean" || !["list", "tree"].includes(config.inner_view ?? "") || !Array.isArray(config.rules) || config.rules.length > 64) throw new Error("Invalid Redis grouping configuration");+ const ids = new Set<string>();+ const rules = config.rules.map((rule) => {+ if (!rule || typeof rule.id !== "string" || !rule.id || ids.has(rule.id) || typeof rule.name !== "string" || !rule.name.trim() || typeof rule.enabled !== "boolean") throw new Error("Invalid Redis grouping rule");+ ids.add(rule.id);+ for (const patterns of [rule.includes, rule.excludes]) {+ if (!Array.isArray(patterns) || patterns.length > 64 || patterns.some((pattern) => typeof pattern !== "string" || new TextEncoder().encode(pattern).length > 1024)) throw new Error("Invalid Redis grouping patterns");+ }+ if (!rule.includes.length && !rule.excludes.length) throw new Error("Empty Redis grouping rule");+ return { ...rule, name: rule.name.trim(), includes: [...rule.includes], excludes: [...rule.excludes] };+ });+ return { version: 1, enabled: config.enabled, inner_view: config.inner_view!, rules };+}++type Token = { kind: "star" } | { kind: "byte"; value: number } | { kind: "any" } | { kind: "class"; values: Set<number>; negate: boolean };++/** Redis MATCH is byte-oriented, including ? and bracket ranges. */+export function compileRedisGroupGlob(pattern: string): (bytes: Uint8Array) => boolean {+ const source = new TextEncoder().encode(pattern);+ const tokens: Token[] = [];+ for (let i = 0; i < source.length; i++) {+ const byte = source[i]!;+ if (byte === 42) {+ if (tokens[tokens.length - 1]?.kind !== "star") tokens.push({ kind: "star" });+ } else if (byte === 63) tokens.push({ kind: "any" });+ else if (byte === 92 && i + 1 < source.length) tokens.push({ kind: "byte", value: source[++i]! });+ else if (byte === 91) {+ const values = new Set<number>();+ let cursor = i + 1;+ const negate = source[cursor] === 94;+ if (negate) cursor++;+ while (cursor < source.length && source[cursor] !== 93) {+ if (source[cursor] === 92 && cursor + 1 < source.length) values.add(source[++cursor]!);+ else if (cursor + 2 < source.length && source[cursor + 1] === 45) {+ const a = source[cursor]!;+ const b = source[cursor + 2]!;+ for (let n = Math.min(a, b); n <= Math.max(a, b); n++) values.add(n);+ cursor += 2;+ } else values.add(source[cursor]!);+ cursor++;+ }+ tokens.push({ kind: "class", values, negate });+ i = cursor;+ } else tokens.push({ kind: "byte", value: byte });+ }+ // Greedy star retry is bounded O(pattern * key), not recursive/exponential.+ return (bytes) => {+ // Redis SCAN special-cases MATCH "*"; other nonempty patterns do not+ // match an empty key, even a run of stars such as "**".+ if (!bytes.length) return source.length === 0 || pattern === "*";+ let p = 0;+ let k = 0;+ let star = -1;+ let retry = 0;+ while (k < bytes.length) {+ const token = tokens[p];+ if (token?.kind === "star") {+ star = p++;+ retry = k;+ continue;+ }+ if (token && (token.kind === "any" || (token.kind === "byte" && token.value === bytes[k]) || (token.kind === "class" && token.values.has(bytes[k]!) !== token.negate))) {+ p++;+ k++;+ continue;+ }+ if (star < 0) return false;+ p = star + 1;+ k = ++retry;+ }+ while (tokens[p]?.kind === "star") p++;+ return p === tokens.length;+ };+}++export function compileRedisKeyGroups(rules: readonly RedisKeyGroupRule[]): (keyRaw: string) => string | null {+ const compiled = rules.filter((rule) => rule.enabled).map((rule) => ({ id: rule.id, includes: rule.includes.map(compileRedisGroupGlob), excludes: rule.excludes.map(compileRedisGroupGlob) }));+ return (keyRaw) => {+ const bytes = Uint8Array.from(atob(keyRaw), (char) => char.charCodeAt(0));+ for (const rule of compiled) {+ if ((!rule.includes.length || rule.includes.some((matches) => matches(bytes))) && !rule.excludes.some((matches) => matches(bytes))) return rule.id;+ }+ return null;+ };+}diff --git a/apps/desktop/src/lib/redis/redisKeyViewScheduler.ts b/apps/desktop/src/lib/redis/redisKeyViewScheduler.tsnew file mode 100644index 0000000000..cc8a5f29e6--- /dev/null+++ b/apps/desktop/src/lib/redis/redisKeyViewScheduler.ts@@ -0,0 +1,12 @@+/** Small cancellation checkpoints need not each consume a browser frame. */+export function createRedisKeyViewYield(options: { now?: () => number; yieldTask?: () => Promise<void>; budgetMs?: number } = {}): () => Promise<void> {+ const now = options.now ?? (() => performance.now());+ const yieldTask = options.yieldTask ?? (() => new Promise<void>((resolve) => setTimeout(resolve, 0)));+ const budget = options.budgetMs ?? 8;+ let started = now();+ return async () => {+ if (now() - started < budget) return;+ await yieldTask();+ started = now();+ };+}diff --git a/apps/desktop/src/lib/redis/redisStickyHeaders.ts b/apps/desktop/src/lib/redis/redisStickyHeaders.tsnew file mode 100644index 0000000000..f29b34801e--- /dev/null+++ b/apps/desktop/src/lib/redis/redisStickyHeaders.ts@@ -0,0 +1,27 @@+import { findRedisHeaderChain, findRedisOuterGroup, type RedisHeaderBoundary, type RedisOuterGroupBoundary } from "./redisKeyGroupIndex";++export const REDIS_GROUP_ROW_HEIGHT = 30;++export function redisStickyHeaders(outer: readonly RedisOuterGroupBoundary[], headers: readonly RedisHeaderBoundary[], scroll: number, height: number, tree: boolean) {+ const size = REDIS_GROUP_ROW_HEIGHT;+ const capacity = tree ? Math.min(3, Math.floor((height * 0.3) / size)) : 1;+ const group = findRedisOuterGroup(outer, scroll / size);+ if (!capacity || !group || group.end <= group.start + 1 || scroll <= group.start * size) return [];+ const outerOffset = Math.min(0, group.end * size - scroll - size);+ if (!tree) return [{ row: group.row, top: outerOffset, omitted: false, path: group.row.label }];+ // Probe only the small overlay band, never the virtual source. Do not cross+ // the outer boundary while choosing descendants at a section transition.+ const chain = findRedisHeaderChain(headers, Math.min(group.end - 0.001, (scroll + (capacity - 1) * size) / size)).filter((entry) => entry.end > entry.start + 1);+ const candidates = chain.length > capacity ? [chain[0]!, ...chain.slice(-(capacity - 1))] : chain;+ if (capacity === 1) candidates.splice(1);+ const path = chain.map((entry) => entry.row.label).join(" › ");+ return candidates.flatMap((entry, slot) => {+ const top = slot * size;+ if (entry.start * size >= scroll + top || entry.end * size <= scroll + top || entry.end <= entry.start + 1) return [];+ return [{ row: entry.row, top: Math.min(top, entry.end * size - scroll - size), omitted: slot === 1 && chain.length > capacity, path }];+ });+}++export function redisStickyHeight(sticky: ReturnType<typeof redisStickyHeaders>) {+ return sticky.reduce((height, row) => Math.max(height, row.top + REDIS_GROUP_ROW_HEIGHT), 0);+}diff --git a/apps/desktop/src/stores/__tests__/connectionStore.redisGrouping.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.redisGrouping.spec.tsnew file mode 100644index 0000000000..81f63cc8b0--- /dev/null+++ b/apps/desktop/src/stores/__tests__/connectionStore.redisGrouping.spec.ts@@ -0,0 +1,25 @@+import { createPinia, setActivePinia } from "pinia";+import { beforeEach, expect, it, vi } from "vitest";+import { defaultRedisKeyGrouping } from "@/lib/redis/redisKeyGrouping";++beforeEach(() => {+ vi.resetModules();+ setActivePinia(createPinia());+ vi.stubGlobal("localStorage", { getItem: () => null, setItem: () => {}, removeItem: () => {} });+});++it("persists presentation without reconnecting and keeps old config after failure", async () => {+ const saveConnections = vi.fn().mockResolvedValue(undefined);+ vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));+ vi.doMock("@/lib/backend/api", () => ({ saveConnections }));+ const { useConnectionStore } = await import("../connectionStore");+ const store = useConnectionStore();+ store.addEphemeralConnection({ id: "group-test", name: "Redis", db_type: "redis", host: "localhost", port: 6379, username: "", password: "" });+ const config = { ...defaultRedisKeyGrouping(), enabled: true };+ await store.updateRedisKeyGrouping("group-test", config);+ expect(saveConnections).toHaveBeenCalledWith([expect.objectContaining({ redis_key_grouping: config })]);+ expect(store.connectedIds.has("group-test")).toBe(true);+ saveConnections.mockRejectedValueOnce(new Error("disk full"));+ await expect(store.updateRedisKeyGrouping("group-test", { ...config, enabled: false })).rejects.toThrow("disk full");+ expect(store.getConfig("group-test")?.redis_key_grouping?.enabled).toBe(true);+});diff --git a/apps/desktop/src/stores/connectionStore.ts b/apps/desktop/src/stores/connectionStore.tsindex bae98426f6..72d556545a 100644--- a/apps/desktop/src/stores/connectionStore.ts+++ b/apps/desktop/src/stores/connectionStore.ts@@ -3433,6 +3433,18 @@ export const useConnectionStore = defineStore("connection", () => {}}+ async function updateRedisKeyGrouping(connectionId: string, grouping: import("@/lib/redis/redisKeyGrouping").RedisKeyGrouping) {+ const { validateRedisKeyGrouping } = await import("@/lib/redis/redisKeyGrouping");+ const validated = validateRedisKeyGrouping(grouping);+ const index = connections.value.findIndex((connection) => connection.id === connectionId);+ if (index < 0) throw new Error("Connection not found");+ const next = [...connections.value];+ next[index] = { ...next[index]!, redis_key_grouping: validated };+ await persistConnections(next);+ // Presentation-only preferences must not invalidate a live connection.+ connections.value = next;+ }+async function renameConnection(connectionId: string, name: string): Promise<boolean> {const trimmed = name.trim();if (!trimmed) return false;@@ -8970,6 +8982,7 @@ export const useConnectionStore = defineStore("connection", () => {pasteConnectionClipboard,addEphemeralConnection,updateConnection,+ updateRedisKeyGrouping,renameConnection,applyGlobalTimeouts,updateConnectionDatabaseInfo,diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.tsindex cc102fd344..7a129f4b15 100644--- a/apps/desktop/src/types/database.ts+++ b/apps/desktop/src/types/database.ts@@ -126,6 +126,7 @@ export interface ConnectionConfig {redis_database_aliases?: Record<string, string>;/** Key-search templates for the Redis browser. Non-empty overrides global settings. */redis_key_templates?: string[];+ redis_key_grouping?: import("@/lib/redis/redisKeyGrouping").RedisKeyGrouping;etcd_endpoints?: string;gbase_server?: string;informix_server?: string;diff --git a/crates/dbx-core/examples/table_import_live_bench.rs b/crates/dbx-core/examples/table_import_live_bench.rsindex 88a2db2204..815fd5a3ca 100644--- a/crates/dbx-core/examples/table_import_live_bench.rs+++ b/crates/dbx-core/examples/table_import_live_bench.rs@@ -199,6 +199,7 @@ fn connection_config(id: &str, database: BenchDatabase) -> Result<ConnectionConfredis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/agent_connection.rs b/crates/dbx-core/src/agent_connection.rsindex 40078c49c3..eb107f4c67 100644--- a/crates/dbx-core/src/agent_connection.rs+++ b/crates/dbx-core/src/agent_connection.rs@@ -741,6 +741,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/agent_tools.rs b/crates/dbx-core/src/agent_tools.rsindex 72c5cd7625..70b84849ee 100644--- a/crates/dbx-core/src/agent_tools.rs+++ b/crates/dbx-core/src/agent_tools.rs@@ -1485,6 +1485,7 @@ for line in sys.stdin:redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/cloud_sync.rs b/crates/dbx-core/src/cloud_sync.rsindex 07b90b0c66..26555def7e 100644--- a/crates/dbx-core/src/cloud_sync.rs+++ b/crates/dbx-core/src/cloud_sync.rs@@ -1802,6 +1802,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),@@ -1864,6 +1865,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),@@ -2124,6 +2126,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/connection.rs b/crates/dbx-core/src/connection.rsindex 1570d65b08..95b708bea1 100644--- a/crates/dbx-core/src/connection.rs+++ b/crates/dbx-core/src/connection.rs@@ -6060,6 +6060,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/connection_secrets.rs b/crates/dbx-core/src/connection_secrets.rsindex 562f3c3aee..9a4ed22372 100644--- a/crates/dbx-core/src/connection_secrets.rs+++ b/crates/dbx-core/src/connection_secrets.rs@@ -869,6 +869,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/db/redis_driver.rs b/crates/dbx-core/src/db/redis_driver.rsindex 1983cb9632..a847fa361c 100644--- a/crates/dbx-core/src/db/redis_driver.rs+++ b/crates/dbx-core/src/db/redis_driver.rs@@ -6988,6 +6988,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/models/connection.rs b/crates/dbx-core/src/models/connection.rsindex 31c43eafb8..208f2c9189 100644--- a/crates/dbx-core/src/models/connection.rs+++ b/crates/dbx-core/src/models/connection.rs@@ -69,6 +69,30 @@ pub fn database_info_from_protocol_value(value: &Value) -> Option<DatabaseConnecserde_json::from_value::<DatabaseInfoEnvelope>(value.clone()).ok()?.database_info}+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]+pub struct RedisKeyGroupRule {+ pub id: String,+ pub name: String,+ pub enabled: bool,+ pub includes: Vec<String>,+ pub excludes: Vec<String>,+}++#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]+#[serde(rename_all = "lowercase")]+pub enum RedisKeyGroupView {+ List,+ Tree,+}++#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]+pub struct RedisKeyGrouping {+ pub version: u8,+ pub enabled: bool,+ pub inner_view: RedisKeyGroupView,+ pub rules: Vec<RedisKeyGroupRule>,+}+#[derive(Clone, Serialize, PartialEq)]pub struct ConnectionConfig {pub id: String,@@ -159,6 +183,8 @@ pub struct ConnectionConfig {/// Empty means inherit the global editor setting.#[serde(default, skip_serializing_if = "Vec::is_empty")]pub redis_key_templates: Vec<String>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub redis_key_grouping: Option<RedisKeyGrouping>,#[serde(default, skip_serializing_if = "String::is_empty")]pub etcd_endpoints: String,#[serde(default, skip_serializing_if = "String::is_empty")]@@ -596,6 +622,8 @@ struct ConnectionConfigData {#[serde(default)]pub redis_key_templates: Vec<String>,#[serde(default)]+ pub redis_key_grouping: Option<RedisKeyGrouping>,+ #[serde(default)]pub etcd_endpoints: String,#[serde(default)]pub gbase_server: String,@@ -669,6 +697,7 @@ impl From<ConnectionConfigData> for ConnectionConfig {redis_scan_page_size: data.redis_scan_page_size,redis_database_aliases: data.redis_database_aliases,redis_key_templates: data.redis_key_templates,+ redis_key_grouping: data.redis_key_grouping,etcd_endpoints: data.etcd_endpoints,gbase_server: data.gbase_server,informix_server: data.informix_server,@@ -693,6 +722,23 @@ impl<'de> Deserialize<'de> for ConnectionConfig {let mut value = Value::deserialize(deserializer)?;migrate_legacy_transport_layers(&mut value);let data = ConnectionConfigData::deserialize(value).map_err(serde::de::Error::custom)?;+ if let Some(grouping) = &data.redis_key_grouping {+ let mut ids = std::collections::HashSet::new();+ if grouping.version != 1+ || grouping.rules.len() > 64+ || grouping.rules.iter().any(|rule| {+ rule.id.is_empty()+ || !ids.insert(&rule.id)+ || rule.name.trim().is_empty()+ || (rule.includes.is_empty() && rule.excludes.is_empty())+ || rule.includes.len() > 64+ || rule.excludes.len() > 64+ || rule.includes.iter().chain(&rule.excludes).any(|pattern| pattern.len() > 1024)+ })+ {+ return Err(serde::de::Error::custom("Invalid Redis grouping configuration"));+ }+ }Ok(data.into())}}@@ -2556,6 +2602,29 @@ fn gaussdb_single_host_port(host: &str, default_port: u16) -> (String, u16) {#[cfg(test)]mod tests {+ #[test]+ fn redis_key_grouping_roundtrip_and_validation() {+ let mut config = mysql_config("root", "", None);+ assert!(config.redis_key_grouping.is_none());+ config.redis_key_grouping = Some(super::RedisKeyGrouping {+ version: 1,+ enabled: true,+ inner_view: super::RedisKeyGroupView::Tree,+ rules: vec![super::RedisKeyGroupRule {+ id: "r1".into(),+ name: "Metadata".into(),+ enabled: true,+ includes: vec!["*:redisson_options".into()],+ excludes: vec![],+ }],+ });+ let value = serde_json::to_value(&config).unwrap();+ let restored: super::ConnectionConfig = serde_json::from_value(value.clone()).unwrap();+ assert_eq!(restored.redis_key_grouping, config.redis_key_grouping);+ let mut invalid = value;+ invalid["redis_key_grouping"]["version"] = serde_json::json!(2);+ assert!(serde_json::from_value::<super::ConnectionConfig>(invalid).is_err());+ }use super::{database_info_from_protocol_value, default_query_timeout_secs, default_redis_key_separator,default_ssh_connect_timeout_secs, sqlserver_legacy_compatibility_param,@@ -2679,6 +2748,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/mq/config.rs b/crates/dbx-core/src/mq/config.rsindex 9c20894c04..d44c5c7301 100644--- a/crates/dbx-core/src/mq/config.rs+++ b/crates/dbx-core/src/mq/config.rs@@ -224,6 +224,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/mq/service.rs b/crates/dbx-core/src/mq/service.rsindex 3ffdbe97f9..7d77ea11b1 100644--- a/crates/dbx-core/src/mq/service.rs+++ b/crates/dbx-core/src/mq/service.rs@@ -944,6 +944,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/nacos/config.rs b/crates/dbx-core/src/nacos/config.rsindex 923574c25b..8e94117f69 100644--- a/crates/dbx-core/src/nacos/config.rs+++ b/crates/dbx-core/src/nacos/config.rs@@ -411,6 +411,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/nacos/service.rs b/crates/dbx-core/src/nacos/service.rsindex 12a75c205f..c0c69bfbeb 100644--- a/crates/dbx-core/src/nacos/service.rs+++ b/crates/dbx-core/src/nacos/service.rs@@ -687,6 +687,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),@@ -764,6 +765,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/production_safety.rs b/crates/dbx-core/src/production_safety.rsindex 591cfabf76..4a008c3a73 100644--- a/crates/dbx-core/src/production_safety.rs+++ b/crates/dbx-core/src/production_safety.rs@@ -805,6 +805,7 @@ mod tests {redis_scan_page_size: Some(1000),redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/query.rs b/crates/dbx-core/src/query.rsindex c288d57879..2b3981cb1d 100644--- a/crates/dbx-core/src/query.rs+++ b/crates/dbx-core/src/query.rs@@ -6739,6 +6739,7 @@ for line in sys.stdin:redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),@@ -9258,6 +9259,7 @@ for line in sys.stdin:redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/schema.rs b/crates/dbx-core/src/schema.rsindex b3571d768a..2def70adef 100644--- a/crates/dbx-core/src/schema.rs+++ b/crates/dbx-core/src/schema.rs@@ -3402,6 +3402,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/storage.rs b/crates/dbx-core/src/storage.rsindex 70e35cbf00..e07c4f3b60 100644--- a/crates/dbx-core/src/storage.rs+++ b/crates/dbx-core/src/storage.rs@@ -5968,6 +5968,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),@@ -6037,6 +6038,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/src/transfer.rs b/crates/dbx-core/src/transfer.rsindex 302813c89c..14b7ea449c 100644--- a/crates/dbx-core/src/transfer.rs+++ b/crates/dbx-core/src/transfer.rs@@ -9573,6 +9573,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),@@ -14380,6 +14381,7 @@ SELECT 1 FROM dual"#redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/tests/dump_docs_fixture.rs b/crates/dbx-core/tests/dump_docs_fixture.rsindex bb34b52de5..563271fea2 100644--- a/crates/dbx-core/tests/dump_docs_fixture.rs+++ b/crates/dbx-core/tests/dump_docs_fixture.rs@@ -66,6 +66,7 @@ fn live_postgres_config(redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/tests/live_postgres_docs_annotations.rs b/crates/dbx-core/tests/live_postgres_docs_annotations.rsindex f7d1b436d2..50b24c2efc 100644--- a/crates/dbx-core/tests/live_postgres_docs_annotations.rs+++ b/crates/dbx-core/tests/live_postgres_docs_annotations.rs@@ -62,6 +62,7 @@ fn live_postgres_config(redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/tests/live_postgres_docs_snapshot.rs b/crates/dbx-core/tests/live_postgres_docs_snapshot.rsindex b78d611ca4..a217073cda 100644--- a/crates/dbx-core/tests/live_postgres_docs_snapshot.rs+++ b/crates/dbx-core/tests/live_postgres_docs_snapshot.rs@@ -57,6 +57,7 @@ fn live_postgres_config(redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/tests/live_postgres_query_result_export.rs b/crates/dbx-core/tests/live_postgres_query_result_export.rsindex 05fe1f1c94..b2ed9a5afb 100644--- a/crates/dbx-core/tests/live_postgres_query_result_export.rs+++ b/crates/dbx-core/tests/live_postgres_query_result_export.rs@@ -62,6 +62,7 @@ fn live_postgres_config(redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/tests/live_postgres_transfer.rs b/crates/dbx-core/tests/live_postgres_transfer.rsindex f5a98e8acb..203494e06b 100644--- a/crates/dbx-core/tests/live_postgres_transfer.rs+++ b/crates/dbx-core/tests/live_postgres_transfer.rs@@ -56,6 +56,7 @@ fn postgres_test_config(id: &str, database: &str) -> ConnectionConfig {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/tests/live_sqlserver_completion.rs b/crates/dbx-core/tests/live_sqlserver_completion.rsindex 36629e1a55..5d3bc9b96a 100644--- a/crates/dbx-core/tests/live_sqlserver_completion.rs+++ b/crates/dbx-core/tests/live_sqlserver_completion.rs@@ -63,6 +63,7 @@ fn live_sqlserver_config(id: &str, database: &str) -> dbx_core::models::connectiredis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/tests/live_sqlserver_query_result_export.rs b/crates/dbx-core/tests/live_sqlserver_query_result_export.rsindex 1e2bf5035b..a24dd1b77e 100644--- a/crates/dbx-core/tests/live_sqlserver_query_result_export.rs+++ b/crates/dbx-core/tests/live_sqlserver_query_result_export.rs@@ -52,6 +52,7 @@ fn live_sqlserver_config(id: &str, database: &str) -> dbx_core::models::connectiredis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/tests/live_sqlserver_transfer.rs b/crates/dbx-core/tests/live_sqlserver_transfer.rsindex e3c64585bf..4d66d83795 100644--- a/crates/dbx-core/tests/live_sqlserver_transfer.rs+++ b/crates/dbx-core/tests/live_sqlserver_transfer.rs@@ -55,6 +55,7 @@ fn live_sqlserver_config(id: &str, database: &str) -> ConnectionConfig {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-core/tests/support/mod.rs b/crates/dbx-core/tests/support/mod.rsindex c00ed8219e..36b90858ee 100644--- a/crates/dbx-core/tests/support/mod.rs+++ b/crates/dbx-core/tests/support/mod.rs@@ -176,6 +176,7 @@ pub fn postgres_test_config(id: &str, port: u16) -> ConnectionConfig {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-web/src/routes/connection.rs b/crates/dbx-web/src/routes/connection.rsindex 553e59e002..f14be71e14 100644--- a/crates/dbx-web/src/routes/connection.rs+++ b/crates/dbx-web/src/routes/connection.rs@@ -864,6 +864,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/crates/dbx-web/src/routes/transfer.rs b/crates/dbx-web/src/routes/transfer.rsindex ce2ea4fe4b..4ae1e3283b 100644--- a/crates/dbx-web/src/routes/transfer.rs+++ b/crates/dbx-web/src/routes/transfer.rs@@ -719,6 +719,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),diff --git a/src-tauri/src/commands/connection.rs b/src-tauri/src/commands/connection.rsindex 87e0c46942..36e7dadc34 100644--- a/src-tauri/src/commands/connection.rs+++ b/src-tauri/src/commands/connection.rs@@ -271,6 +271,7 @@ mod tests {redis_scan_page_size: None,redis_database_aliases: Default::default(),redis_key_templates: Vec::new(),+ redis_key_grouping: None,etcd_endpoints: String::new(),gbase_server: String::new(),informix_server: String::new(),