25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { reactive } from "vue";
import type { ObjectBrowserRow } from "@/lib/table/objectBrowserRows";
import { cacheObjectBrowserRows, clearObjectBrowserRowsCache, createObjectBrowserRowsCacheWriteToken, getCachedObjectBrowserRows, getCachedObjectBrowserRowsForScaffold, invalidateObjectBrowserRowsCache } from "@/lib/table/objectBrowserRowsCache";
const row: ObjectBrowserRow = {
id: "table:users",
name: "users",
displayName: "users",
type: "TABLE",
};
function cacheRows(scope: Parameters<typeof createObjectBrowserRowsCacheWriteToken>[0], rows: readonly ObjectBrowserRow[] = [row]) {
return cacheObjectBrowserRows(createObjectBrowserRowsCacheWriteToken(scope), rows);
}
function deferred<T>() {
let resolve!: (value: T) => void;
const promise = new Promise<T>((resolvePromise) => {
resolve = resolvePromise;
});
return { promise, resolve };
}
describe("objectBrowserRowsCache", () => {
beforeEach(() => clearObjectBrowserRowsCache());
afterEach(() => vi.useRealTimers());
it("restores cached rows only for the same object browser scope", () => {
const scope = { connectionId: "c1", database: "db", schema: "public" };
cacheRows(scope);
expect(getCachedObjectBrowserRows(scope)).toEqual([row]);
expect(getCachedObjectBrowserRows({ ...scope, schema: "archive" })).toBeUndefined();
expect(getCachedObjectBrowserRows({ ...scope, connectionId: "c2" })).toBeUndefined();
});
it("returns copies so component updates do not mutate the cached rows", () => {
const scope = { connectionId: "c1", database: "db", schema: "public" };
cacheRows(scope);
const cached = getCachedObjectBrowserRows(scope)!;
cached[0].displayName = "changed";
expect(getCachedObjectBrowserRows(scope)?.[0].displayName).toBe("users");
});
it("separates the trigger exact contract from legacy scaffolds and preserves raw scopes", () => {
const legacy = { connectionId: "c1", database: "db", schema: " Owner " };
const exact = { ...legacy, oracleTriggerContract: 1 as const };
cacheRows(legacy);
expect(getCachedObjectBrowserRows(exact)).toBeUndefined();
cacheRows(exact, [{ ...row, name: "Exact" }]);
expect(getCachedObjectBrowserRows(legacy)?.[0].name).toBe("users");
expect(getCachedObjectBrowserRows(exact)?.[0].name).toBe("Exact");
expect(getCachedObjectBrowserRows({ ...exact, schema: "Owner" })).toBeUndefined();
});
it("does not share mutable nested trigger snapshots across a cache boundary", () => {
const scope = { connectionId: "c1", database: "db", schema: " Owner ", oracleTriggerContract: 1 as const };
const triggerRow: ObjectBrowserRow = {
...row,
type: "TRIGGER",
trigger: {
name: " Trigger ",
event: "INSERT",
timing: "BEFORE",
enabled: false,
oracle_metadata: { contractVersion: 1, identityMode: "exact", owner: " Owner ", name: " Trigger ", engine: "oracle", scope: "VIEW", parent: { owner: "ParentOwner", name: "Parent", objectType: "VIEW" }, reads: { identity: { state: "available" } } },
},
};
cacheRows(scope, [reactive(triggerRow)]);
triggerRow.trigger!.oracle_metadata!.parent!.name = "changed at producer";
const cached = getCachedObjectBrowserRows(scope)!;
expect(cached[0].trigger!.oracle_metadata!.parent!.name).toBe("Parent");
cached[0].trigger!.oracle_metadata!.reads.identity!.state = "error";
expect(getCachedObjectBrowserRows(scope)![0].trigger!.oracle_metadata!.reads.identity!.state).toBe("available");
});
it("invalidates both trigger contracts only in the affected raw schema and rejects their late writers", () => {
const exact = { connectionId: "c1", database: "db", schema: " Owner ", oracleTriggerContract: 1 as const };
const legacy = { connectionId: "c1", database: "db", schema: " Owner " };
const other = { ...exact, schema: "Owner" };
const exactToken = createObjectBrowserRowsCacheWriteToken(exact);
const legacyToken = createObjectBrowserRowsCacheWriteToken(legacy);
cacheRows(exact);
cacheRows(legacy);
cacheRows(other);
expect(invalidateObjectBrowserRowsCache({ connectionId: "c1", database: "db", schema: " Owner " })).toBe(2);
expect(cacheObjectBrowserRows(exactToken, [row])).toBeUndefined();
expect(cacheObjectBrowserRows(legacyToken, [row])).toBeUndefined();
expect(getCachedObjectBrowserRows(other)).toEqual([row]);
});
it("restores fresh rows when a remounted component reads the shared cache", () => {
vi.useFakeTimers();
vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
const scope = { connectionId: "c1", database: "db", schema: "public" };
cacheRows(scope);
expect(getCachedObjectBrowserRows(scope)).toEqual([row]);
});
it("rejects cached rows after the TTL", () => {
vi.useFakeTimers();
vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
const scope = { connectionId: "c1", database: "db", schema: "public" };
cacheRows(scope);
vi.advanceTimersByTime(30_001);
expect(getCachedObjectBrowserRows(scope)).toBeUndefined();
});
it("invalidates matching connection and database scopes", () => {
const first = { connectionId: "c1", database: "db1", schema: "public" };
const second = { connectionId: "c1", database: "db2", schema: "public" };
const third = { connectionId: "c2", database: "db1", schema: "public" };
cacheRows(first);
cacheRows(second);
cacheRows(third);
expect(invalidateObjectBrowserRowsCache({ connectionId: "c1", database: "db1" })).toBe(1);
expect(getCachedObjectBrowserRows(first)).toBeUndefined();
expect(getCachedObjectBrowserRows(second)).toEqual([row]);
expect(getCachedObjectBrowserRows(third)).toEqual([row]);
});
it("rejects a late cache write started before matching metadata invalidation", async () => {
const invalidatedScope = { connectionId: "c1", database: "db1", schema: "public" };
const isolatedScope = { connectionId: "c1", database: "db2", schema: "public" };
const invalidatedToken = createObjectBrowserRowsCacheWriteToken(invalidatedScope);
const isolatedToken = createObjectBrowserRowsCacheWriteToken(isolatedScope);
const pendingRows = deferred<readonly ObjectBrowserRow[]>();
const lateWrite = pendingRows.promise.then((rows) => cacheObjectBrowserRows(invalidatedToken, rows));
invalidateObjectBrowserRowsCache({ connectionId: "c1", database: "db1", schema: "public" });
pendingRows.resolve([row]);
expect(await lateWrite).toBeUndefined();
expect(cacheObjectBrowserRows(isolatedToken, [row])).toEqual(expect.any(Number));
expect(getCachedObjectBrowserRows(invalidatedScope)).toBeUndefined();
expect(getCachedObjectBrowserRows(isolatedScope)).toEqual([row]);
});
it("rejects old write tokens after their bounded generation state is evicted", () => {
const staleScope = { connectionId: "stale", database: "db", schema: "public" };
const staleToken = createObjectBrowserRowsCacheWriteToken(staleScope);
for (let index = 0; index < 128; index += 1) {
createObjectBrowserRowsCacheWriteToken({ connectionId: `c${index}`, database: "db", schema: "public" });
}
expect(cacheObjectBrowserRows(staleToken, [row])).toBeUndefined();
expect(getCachedObjectBrowserRows(staleScope)).toBeUndefined();
});
it("preserves the original object list freshness when statistics update cached rows", () => {
vi.useFakeTimers();
vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
const scope = { connectionId: "c1", database: "db", schema: "public" };
const token = createObjectBrowserRowsCacheWriteToken(scope);
const fetchedAt = cacheObjectBrowserRows(token, [row]);
vi.advanceTimersByTime(29_000);
cacheObjectBrowserRows(token, [{ ...row, estimatedRows: 42 }], { cachedAt: fetchedAt });
expect(getCachedObjectBrowserRows(scope)?.[0].estimatedRows).toBe(42);
vi.advanceTimersByTime(1_001);
expect(getCachedObjectBrowserRows(scope)).toBeUndefined();
});
it("projects table invalidation onto the object list cache scope", () => {
const scope = { connectionId: "c1", database: "db", schema: "public" };
cacheRows(scope, [{ ...row, estimatedRows: 42 }]);
expect(invalidateObjectBrowserRowsCache({ ...scope, tableName: "users" })).toBe(1);
expect(getCachedObjectBrowserRows(scope)).toBeUndefined();
});
describe("scaffold reads (allowStale)", () => {
it("returns a fresh hit marked stale=false before the TTL", () => {
vi.useFakeTimers();
vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
const scope = { connectionId: "c1", database: "db", schema: "public" };
cacheRows(scope);
const hit = getCachedObjectBrowserRowsForScaffold(scope);
expect(hit).toBeDefined();
expect(hit!.rows).toEqual([row]);
expect(hit!.stale).toBe(false);
expect(hit!.ageMs).toBe(0);
expect(hit!.cachedAt).toBe(Date.now());
});
it("surfaces an expired entry as a stale scaffold instead of refusing it", () => {
vi.useFakeTimers();
vi.setSystemTime(new Date("2026-07-28T00:00:00Z"));
const scope = { connectionId: "c1", database: "db", schema: "public" };
cacheRows(scope);
vi.advanceTimersByTime(30_001);
const hit = getCachedObjectBrowserRowsForScaffold(scope);
expect(hit).toBeDefined();
expect(hit!.rows).toEqual([row]);
expect(hit!.stale).toBe(true);
expect(hit!.ageMs).toBeGreaterThan(30_000);
});
it("returns undefined when no scaffold is available (uncached or invalidated)", () => {
const scope = { connectionId: "c1", database: "db", schema: "public" };
expect(getCachedObjectBrowserRowsForScaffold(scope)).toBeUndefined();
cacheRows(scope);
invalidateObjectBrowserRowsCache({ connectionId: "c1", database: "db", schema: "public" });
expect(getCachedObjectBrowserRowsForScaffold(scope)).toBeUndefined();
});
});
});