feat(redis): add stream consumer group monitoring

This commit is contained in:
onenewcode authored and GitHub committed 2026-07-28 23:16:39 +08:00
1 parent 99cfa1b516
commit 31f0b7d6ef
23 files changed
+2092 -44

No files matched your search

@@ -243,7 +243,7 @@ describe("native RedisJSON editor", () => {
const labels = templateElements(parsedViewer.descriptor.template!.ast as unknown as TemplateElement);
const stringTextarea = findTemplateElement((element) => element.tag === "textarea" && directiveExpression(element, "model") === "editValue");
const memberTextarea = findTemplateElement((element) => element.tag === "textarea" && directiveExpression(element, "model") === "memberEditValue");
const refreshButton = findTemplateElement((element) => element.tag === "Button" && directiveExpression(element, "on", "click") === "load");
const refreshButton = findTemplateElement((element) => element.tag === "Button" && directiveExpression(element, "on", "click") === "refreshValueAndStreamGroups");
expect(autoRefresh.getText()).toContain("if (hasUnsavedRedisDraft.value) return;");
expect(autoRefresh.getText()).toContain("load({ preserveDraft: true })");
@@ -0,0 +1,127 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
invoke: vi.fn(),
}));
vi.mock("@tauri-apps/api/core", () => ({
invoke: mocks.invoke,
}));
vi.mock("@tauri-apps/api/event", () => ({
listen: vi.fn(),
}));
describe("Redis stream monitoring Tauri API", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.unstubAllGlobals();
});
it("invokes the group, consumer, and pending read commands with binary-safe raw names", async () => {
mocks.invoke.mockResolvedValue(undefined);
const { redisGetStreamConsumers, redisGetStreamGroups, redisGetStreamPending } = await import("@/lib/backend/tauri");
await redisGetStreamGroups("redis-1", 2, "b3JkZXJz");
await redisGetStreamConsumers("redis-1", 2, "b3JkZXJz", "Z3JvdXAALQ==");
await redisGetStreamPending("redis-1", 2, "b3JkZXJz", "Z3JvdXAALQ==", "1714470000000-17");
expect(mocks.invoke).toHaveBeenNthCalledWith(1, "redis_get_stream_groups", {
connectionId: "redis-1",
db: 2,
keyRaw: "b3JkZXJz",
});
expect(mocks.invoke).toHaveBeenNthCalledWith(2, "redis_get_stream_consumers", {
connectionId: "redis-1",
db: 2,
keyRaw: "b3JkZXJz",
groupRaw: "Z3JvdXAALQ==",
});
expect(mocks.invoke).toHaveBeenNthCalledWith(3, "redis_get_stream_pending", {
connectionId: "redis-1",
db: 2,
keyRaw: "b3JkZXJz",
groupRaw: "Z3JvdXAALQ==",
cursor: "1714470000000-17",
});
});
it("passes an optional binary-safe consumer name to the pending command", async () => {
mocks.invoke.mockResolvedValue(undefined);
const { redisGetStreamPending } = await import("@/lib/backend/tauri");
await redisGetStreamPending("redis-1", 2, "b3JkZXJz", "Z3JvdXAALQ==", "1714470000000-17", "d29ya2VyLWE=");
expect(mocks.invoke).toHaveBeenCalledWith("redis_get_stream_pending", {
connectionId: "redis-1",
db: 2,
keyRaw: "b3JkZXJz",
groupRaw: "Z3JvdXAALQ==",
cursor: "1714470000000-17",
consumerRaw: "d29ya2VyLWE=",
});
});
});
describe("Redis stream monitoring HTTP API", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.unstubAllGlobals();
});
function stubFetch() {
const fetchMock = vi.fn().mockResolvedValue({
ok: true,
json: vi.fn().mockResolvedValue(undefined),
});
vi.stubGlobal("fetch", fetchMock);
return fetchMock;
}
function lastCall(fetchMock: ReturnType<typeof stubFetch>): { url: string; body: Record<string, unknown> } {
const [url, init] = fetchMock.mock.calls.at(-1) as [string, RequestInit];
return { url, body: JSON.parse(String(init.body)) as Record<string, unknown> };
}
it("posts group, consumer, and pending queries to their read-only endpoints", async () => {
const fetchMock = stubFetch();
const { redisGetStreamConsumers, redisGetStreamGroups, redisGetStreamPending } = await import("@/lib/backend/http");
await redisGetStreamGroups("redis-1", 2, "b3JkZXJz");
expect(lastCall(fetchMock)).toEqual({
url: "/api/redis/get-stream-groups",
body: { connectionId: "redis-1", db: 2, keyRaw: "b3JkZXJz" },
});
await redisGetStreamConsumers("redis-1", 2, "b3JkZXJz", "Z3JvdXAALQ==");
expect(lastCall(fetchMock)).toEqual({
url: "/api/redis/get-stream-consumers",
body: { connectionId: "redis-1", db: 2, keyRaw: "b3JkZXJz", groupRaw: "Z3JvdXAALQ==" },
});
await redisGetStreamPending("redis-1", 2, "b3JkZXJz", "Z3JvdXAALQ==", "1714470000000-17");
expect(lastCall(fetchMock)).toEqual({
url: "/api/redis/get-stream-pending",
body: { connectionId: "redis-1", db: 2, keyRaw: "b3JkZXJz", groupRaw: "Z3JvdXAALQ==", cursor: "1714470000000-17" },
});
});
it("posts a consumer-scoped pending query", async () => {
const fetchMock = stubFetch();
const { redisGetStreamPending } = await import("@/lib/backend/http");
await redisGetStreamPending("redis-1", 2, "b3JkZXJz", "Z3JvdXAALQ==", "1714470000000-17", "d29ya2VyLWE=");
expect(lastCall(fetchMock)).toEqual({
url: "/api/redis/get-stream-pending",
body: {
connectionId: "redis-1",
db: 2,
keyRaw: "b3JkZXJz",
groupRaw: "Z3JvdXAALQ==",
cursor: "1714470000000-17",
consumerRaw: "d29ya2VyLWE=",
},
});
});
});
+8
View File
@@ -387,6 +387,9 @@ export const redisScanKeys = forward("redisScanKeys");
export const redisScanKeysBatch = forward("redisScanKeysBatch");
export const redisScanValues = forward("redisScanValues");
export const redisGetValue = forward("redisGetValue");
export const redisGetStreamGroups = forward("redisGetStreamGroups");
export const redisGetStreamConsumers = forward("redisGetStreamConsumers");
export const redisGetStreamPending = forward("redisGetStreamPending");
export const redisSetString = forward("redisSetString");
export const redisDeleteKey = forward("redisDeleteKey");
export const redisHashSet = forward("redisHashSet");
@@ -627,8 +630,13 @@ export type {
RedisKeyInfo,
RedisListItem,
RedisSetItem,
RedisStreamConsumer,
RedisStreamEntry,
RedisStreamField,
RedisStreamGroup,
RedisStreamMetric,
RedisStreamPendingEntry,
RedisStreamPendingPage,
RedisValue,
RedisValueData,
RedisZsetItem,
+15
View File
@@ -68,6 +68,9 @@ import type {
UpdateDownloadSource,
RedisCollectionPage,
RedisDatabaseInfo,
RedisStreamConsumer,
RedisStreamGroup,
RedisStreamPendingPage,
RedisValue,
RedisScanResult,
RedisCommandResult,
@@ -1999,6 +2002,18 @@ export async function redisGetValue(connectionId: string, db: number, keyRaw: st
return post("/api/redis/get-value", { connectionId, db, keyRaw });
}
export async function redisGetStreamGroups(connectionId: string, db: number, keyRaw: string): Promise<RedisStreamGroup[]> {
return post("/api/redis/get-stream-groups", { connectionId, db, keyRaw });
}
export async function redisGetStreamConsumers(connectionId: string, db: number, keyRaw: string, groupRaw: string): Promise<RedisStreamConsumer[]> {
return post("/api/redis/get-stream-consumers", { connectionId, db, keyRaw, groupRaw });
}
export async function redisGetStreamPending(connectionId: string, db: number, keyRaw: string, groupRaw: string, cursor?: string, consumerRaw?: string): Promise<RedisStreamPendingPage> {
return post("/api/redis/get-stream-pending", { connectionId, db, keyRaw, groupRaw, cursor, ...(consumerRaw === undefined ? {} : { consumerRaw }) });
}
export async function redisSetString(connectionId: string, db: number, keyRaw: string, value: string, ttl?: number): Promise<void> {
return post("/api/redis/set-string", { connectionId, db, keyRaw, value, ttl });
}
+43
View File
@@ -1650,6 +1650,37 @@ export interface RedisStreamEntry {
fields: RedisStreamField[];
}
// Redis counters above Number.MAX_SAFE_INTEGER are transported as decimal strings.
export type RedisStreamMetric = number | string;
export interface RedisStreamGroup {
name: RedisBlob;
consumers: RedisStreamMetric;
pending: RedisStreamMetric;
last_delivered_id: string;
entries_read?: RedisStreamMetric;
lag?: RedisStreamMetric;
}
export interface RedisStreamConsumer {
name: RedisBlob;
pending: RedisStreamMetric;
idle_ms: RedisStreamMetric;
inactive_ms?: RedisStreamMetric;
}
export interface RedisStreamPendingEntry {
id: string;
consumer: RedisBlob;
idle_ms: RedisStreamMetric;
deliveries: RedisStreamMetric;
}
export interface RedisStreamPendingPage {
entries: RedisStreamPendingEntry[];
next_cursor?: string;
}
export type RedisValueData =
| { kind: "string"; content: RedisBlob }
| { kind: "json"; value: string }
@@ -1718,6 +1749,18 @@ export async function redisGetValue(connectionId: string, db: number, keyRaw: st
return invoke("redis_get_value", { connectionId, db, keyRaw });
}
export async function redisGetStreamGroups(connectionId: string, db: number, keyRaw: string): Promise<RedisStreamGroup[]> {
return invoke("redis_get_stream_groups", { connectionId, db, keyRaw });
}
export async function redisGetStreamConsumers(connectionId: string, db: number, keyRaw: string, groupRaw: string): Promise<RedisStreamConsumer[]> {
return invoke("redis_get_stream_consumers", { connectionId, db, keyRaw, groupRaw });
}
export async function redisGetStreamPending(connectionId: string, db: number, keyRaw: string, groupRaw: string, cursor?: string, consumerRaw?: string): Promise<RedisStreamPendingPage> {
return invoke("redis_get_stream_pending", { connectionId, db, keyRaw, groupRaw, cursor, ...(consumerRaw === undefined ? {} : { consumerRaw }) });
}
export async function redisSetString(connectionId: string, db: number, keyRaw: string, value: string, ttl?: number): Promise<void> {
return invoke("redis_set_string", { connectionId, db, keyRaw, value, ttl });
}