Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

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.vue
index 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 = ""): ConnectionCo
config.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.vue
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.vue
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.vue
index 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 } fro
import { 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.vue
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.rs
index 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<ConnectionConf
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_connection.rs b/crates/dbx-core/src/agent_connection.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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<DatabaseConnec
serde_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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::connecti
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_query_result_export.rs b/crates/dbx-core/tests/live_sqlserver_query_result_export.rs
index 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::connecti
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_transfer.rs b/crates/dbx-core/tests/live_sqlserver_transfer.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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(),