25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
feat(object-browser): preserve object list on return via stale cache
Abeautifulsnow8642e1a5996d
diff --git a/apps/desktop/src/components/objects/ObjectBrowser.vue b/apps/desktop/src/components/objects/ObjectBrowser.vueindex bad871d1f8..01d577ec74 100644--- a/apps/desktop/src/components/objects/ObjectBrowser.vue+++ b/apps/desktop/src/components/objects/ObjectBrowser.vue@@ -155,7 +155,7 @@ import { createSidePanelRequestGuard } from "@/lib/table/sidePanelRequestGuard";import { runBatchTableTruncate } from "@/lib/table/batchTableTruncate";import { tableColumnDefaultDisplayValue } from "@/lib/table/tableColumnDefaultPresentation";import { gaussdbMTypeDisplayName } from "@/lib/table/postgresDataTypeHelp";-import { cacheObjectBrowserRows, createObjectBrowserRowsCacheWriteToken, getCachedObjectBrowserRows, type ObjectBrowserRowsCacheScope, type ObjectBrowserRowsCacheWriteToken } from "@/lib/table/objectBrowserRowsCache";+import { cacheObjectBrowserRows, createObjectBrowserRowsCacheWriteToken, getCachedObjectBrowserRowsForScaffold, type ObjectBrowserRowsCacheScope, type ObjectBrowserRowsCacheWriteToken } from "@/lib/table/objectBrowserRowsCache";import { createObjectBrowserRowsLoadGuard, type ObjectBrowserRowsLoadHandle } from "@/lib/table/objectBrowserRowsLoadGuard";import { loadObjectDdl, type ObjectDdlRequest } from "@/lib/metadata/objectDdlCache";import { loadObjectMetadataFacet } from "@/lib/metadata/objectMetadataCache";@@ -211,6 +211,8 @@ const sortKey = ref<ObjectBrowserSortKey>("name");const sortDirection = ref<ObjectBrowserSortDirection>("asc");const loadingSchemas = ref(false);const loadingObjects = ref(false);+const refreshingObjects = ref(false);+const scaffoldRefreshError = ref("");const sourceLoading = ref(false);const sourceContent = ref("");const sourceError = ref("");@@ -2815,22 +2817,57 @@ watch([() => props.initialEventName, () => props.initialEventOpenRequestId, () =openInitialEventIfNeeded();});-async function loadObjects(options?: { allowCached?: boolean }) {+async function loadObjects(options?: { allowCached?: boolean; preserveExistingRows?: boolean }) {error.value = "";+ // A new load supersedes any in-flight one, so reset the transient refresh flags+ // on entry. A superseded request's finally() can no longer run (the guard's+ // epoch moved on) and would otherwise leave refreshingObjects stuck spinning+ // the toolbar icon — the newest request owns the spinner state from here.+ loadingObjects.value = false;+ refreshingObjects.value = false;+ scaffoldRefreshError.value = "";+ // True when we are revalidating on top of visible rows (a stale-cache scaffold, or a+ // same-instance refresh) — a failure then keeps the rows and raises a non-blocking+ // banner instead of replacing the whole list with a full-area error.+ let scaffoldRefresh = false;const schema = needsSchema.value ? selectedSchema.value || "" : props.database;const request = objectBrowserRowsLoadGuard.start(objectBrowserRowsCacheScope(schema));const cacheWriteToken = createObjectBrowserRowsCacheWriteToken(request.scope);- if (options?.allowCached) {- const cachedRows = getCachedObjectBrowserRows(request.scope);- if (cachedRows) {- applyObjectBrowserRows(cachedRows);- finishObjectBrowserRowsLoad();- return;++ // finishObjectBrowserRowsLoad() is idempotent, but keep the default-filter /+ // viewport restores to a single run per load so the events-preferred-filter case+ // doesn't leave preserveObjectFilterScrollOnce latched across an extra call.+ let finished = false;+ const finishOnce = () => {+ if (finished) return;+ finished = true;+ finishObjectBrowserRowsLoad();+ };++ const cached = options?.allowCached ? getCachedObjectBrowserRowsForScaffold(request.scope) : undefined;+ if (cached) {+ // Scaffold the last-known rows so returning to this tab shows them instantly+ // instead of flashing an empty list. A fresh entry (< TTL) is authoritative on+ // its own; a stale one is presented and then revalidated in the background.+ applyObjectBrowserRows(cached.rows);+ finishOnce();+ if (!cached.stale) return;+ scaffoldRefresh = true;+ refreshingObjects.value = true;+ } else {+ // No scaffold: first load in this scope, cache invalidated by a DDL mutation,+ // or the caller wants a true reload. If the caller explicitly asked to keep the+ // current rows (same-instance refresh) and rows exist, refresh without blanking.+ const keepExisting = options?.preserveExistingRows && rows.value.length > 0;+ if (keepExisting) {+ scaffoldRefresh = true;+ refreshingObjects.value = true;+ } else {+ loadingObjects.value = true;+ rows.value = [];}}- loadingObjects.value = true;- rows.value = [];try {const nextRows = props.connection.db_type === "mongodb" ? await loadMongoObjectBrowserRows(request.scope.connectionId, request.scope.database) : await loadSqlObjectBrowserRows(request);if (!objectBrowserRowsLoadGuard.isCurrent(request)) return;@@ -2839,9 +2876,19 @@ async function loadObjects(options?: { allowCached?: boolean }) {if (props.connection.db_type !== "mongodb") void loadObjectStatistics(request, cacheWriteToken, cachedAt);} catch (e: any) {if (!objectBrowserRowsLoadGuard.isCurrent(request)) return;- error.value = translateBackendError(t, e);+ // Keep visible rows on a background revalidate failure — surface a lightweight+ // banner rather than replacing the scaffold (or same-instance refresh) list.+ if (scaffoldRefresh) {+ scaffoldRefreshError.value = translateBackendError(t, e);+ } else {+ error.value = translateBackendError(t, e);+ }} finally {- if (objectBrowserRowsLoadGuard.isCurrent(request)) finishObjectBrowserRowsLoad();+ if (objectBrowserRowsLoadGuard.isCurrent(request)) {+ loadingObjects.value = false;+ refreshingObjects.value = false;+ finishOnce();+ }}}@@ -2894,15 +2941,15 @@ function normalizeStatisticNumber(value: number | null | undefined): number | nureturn typeof value === "number" && Number.isFinite(value) ? value : null;}-async function reload(options?: { allowCachedObjects?: boolean; contextEpoch?: number }) {+async function reload(options?: { allowCachedObjects?: boolean; contextEpoch?: number; preserveExistingRows?: boolean }) {const epoch = options?.contextEpoch ?? objectBrowserRowsLoadGuard.invalidate();if (!(await loadSchemas(epoch))) return;if (!objectBrowserRowsLoadGuard.isEpochCurrent(epoch)) return;- await loadObjects({ allowCached: options?.allowCachedObjects });+ await loadObjects({ allowCached: options?.allowCachedObjects, preserveExistingRows: options?.preserveExistingRows });}function refresh(): boolean {- void reload();+ void reload({ preserveExistingRows: true });void refreshActiveTableInfo();return true;}@@ -3302,7 +3349,7 @@ function getObjectBrowserMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {<Square v-else class="h-3.5 w-3.5" /></Button><Button variant="ghost" size="icon" class="h-7 w-7" :title="refreshTooltip" :disabled="loadingObjects" @click="refresh">- <RefreshCw class="h-3.5 w-3.5" :class="{ 'animate-spin': loadingObjects }" />+ <RefreshCw class="h-3.5 w-3.5" :class="{ 'animate-spin': loadingObjects || refreshingObjects }" /></Button><Button v-if="canPasteTableClipboard()" variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="openPasteTableDialog"><Clipboard class="mr-1.5 h-3.5 w-3.5" />@@ -3382,6 +3429,10 @@ function getObjectBrowserMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {</Button></div>+ <div v-if="scaffoldRefreshError" role="status" class="flex h-8 shrink-0 items-center gap-2 border-b border-destructive/30 bg-destructive/5 px-3 text-xs text-destructive">+ <RefreshCw class="h-3 w-3 shrink-0" />+ <span class="min-w-0 truncate">{{ scaffoldRefreshError }}</span>+ </div><div v-if="loadingObjects" class="flex flex-1 items-center justify-center gap-2 text-sm text-muted-foreground"><Loader2 class="h-4 w-4 animate-spin" />{{ t("objects.loading") }}diff --git a/apps/desktop/src/components/objects/__tests__/ObjectBrowserMetadataRefresh.spec.ts b/apps/desktop/src/components/objects/__tests__/ObjectBrowserMetadataRefresh.spec.tsindex 9fe3797163..cf1eeab727 100644--- a/apps/desktop/src/components/objects/__tests__/ObjectBrowserMetadataRefresh.spec.ts+++ b/apps/desktop/src/components/objects/__tests__/ObjectBrowserMetadataRefresh.spec.ts@@ -20,7 +20,7 @@ describe("ObjectBrowser table metadata refresh", () => {it("refreshes the object list and the open table-info tab from the toolbar", () => {const refresh = functionBody("refresh");- expect(refresh).toContain("void reload();");+ expect(refresh).toContain("void reload({ preserveExistingRows: true });");expect(refresh).toContain("void refreshActiveTableInfo();");expect(source).toContain('@click="refresh"');});diff --git a/apps/desktop/src/components/objects/__tests__/ObjectBrowserScaffoldRefresh.spec.ts b/apps/desktop/src/components/objects/__tests__/ObjectBrowserScaffoldRefresh.spec.tsnew file mode 100644index 0000000000..6c242a05ea--- /dev/null+++ b/apps/desktop/src/components/objects/__tests__/ObjectBrowserScaffoldRefresh.spec.ts@@ -0,0 +1,58 @@+import { readFileSync } from "node:fs";+import { describe, expect, it } from "vitest";++const source = readFileSync(new URL("../ObjectBrowser.vue", import.meta.url), "utf8");++function functionBody(name: string): string {+ const signature = new RegExp(`(?:async\\s+)?function\\s+${name}\\s*\\([^)]*\\)\\s*(?::\\s*[^\\{]+)?\\{`, "m").exec(source);+ if (!signature) throw new Error(`Missing function ${name}`);+ const bodyStart = signature.index + signature[0].length;+ let depth = 1;+ for (let index = bodyStart; index < source.length; index += 1) {+ if (source[index] === "{") depth += 1;+ else if (source[index] === "}") depth -= 1;+ if (depth === 0) return source.slice(bodyStart, index);+ }+ throw new Error(`Unclosed function ${name}`);+}++describe("ObjectBrowser scaffold refresh race", () => {+ // Scope A hits stale cache and starts a background revalidate (refreshingObjects = true);+ // before it settles, the user switches to scope B which hits fresh cache and early-returns.+ // A's finally() can no longer run (the load guard's epoch moved on), so the flag must be+ // cleared by the newest request (B) at entry — otherwise the toolbar icon spins forever.+ it("resets the transient refresh flags at entry, before the cache decision", () => {+ const body = functionBody("loadObjects");++ const loadingReset = body.indexOf("loadingObjects.value = false;");+ const refreshingReset = body.indexOf("refreshingObjects.value = false;");+ const cachedBranch = body.indexOf("const cached =");++ expect(loadingReset).toBeGreaterThanOrEqual(0);+ expect(refreshingReset).toBeGreaterThanOrEqual(0);+ // Both resets must precede the cached fresh/stale decision so the newest request+ // owns the spinner state even when a superseded request's finally() cannot run.+ expect(Math.min(loadingReset, refreshingReset)).toBeLessThan(cachedBranch);+ // And neither flag may be turned back on before the branch decides the indicator.+ expect(body.indexOf("refreshingObjects.value = true;")).toBeGreaterThan(cachedBranch);+ expect(body.indexOf("loadingObjects.value = true;")).toBeGreaterThan(cachedBranch);+ });++ it("exposes a non-blocking refresh flag distinct from the blocking full-area load", () => {+ expect(source).toContain("const refreshingObjects = ref(false);");+ expect(functionBody("loadObjects")).toContain("refreshingObjects.value = true;");+ expect(functionBody("loadObjects")).toContain("loadingObjects.value = true;");+ });++ it("keeps visible rows on a background revalidate failure (scaffold-preserving error)", () => {+ expect(source).toContain('const scaffoldRefreshError = ref("");');+ const body = functionBody("loadObjects");+ // A scaffold/refresh revalidate failure must route to the non-blocking banner+ // (scaffoldRefreshError) and keep the visible rows, not replace them with the+ // blocking full-area error.+ expect(body).toContain("scaffoldRefresh = true;");+ expect(body).toContain("if (scaffoldRefresh) {");+ expect(body).toContain("scaffoldRefreshError.value = translateBackendError(t, e)");+ expect(source).toContain('v-if="scaffoldRefreshError"');+ });+});diff --git a/apps/desktop/src/lib/__tests__/table/contentAreaObjectBrowserCatalog.spec.ts b/apps/desktop/src/lib/__tests__/table/contentAreaObjectBrowserCatalog.spec.tsindex a2099deeb9..d8a5ac025c 100644--- a/apps/desktop/src/lib/__tests__/table/contentAreaObjectBrowserCatalog.spec.ts+++ b/apps/desktop/src/lib/__tests__/table/contentAreaObjectBrowserCatalog.spec.ts@@ -36,7 +36,7 @@ describe("ContentArea object browser refresh wiring", () => {});it("exposes object and active table-info reloads as refresh", () => {- expect(objectBrowserSource).toMatch(/function refresh\(\): boolean \{\s+void reload\(\);\s+void refreshActiveTableInfo\(\);\s+return true;\s+\}/);+ expect(objectBrowserSource).toMatch(/function refresh\(\): boolean \{\s+void reload\(\{ preserveExistingRows: true \}\);\s+void refreshActiveTableInfo\(\);\s+return true;\s+\}/);expect(objectBrowserSource).toContain("defineExpose({ focusSearch, refresh });");});diff --git a/apps/desktop/src/lib/metadata/__tests__/objectBrowserRowsCache.spec.ts b/apps/desktop/src/lib/metadata/__tests__/objectBrowserRowsCache.spec.tsindex 93eee2a09f..77b96acc25 100644--- a/apps/desktop/src/lib/metadata/__tests__/objectBrowserRowsCache.spec.ts+++ b/apps/desktop/src/lib/metadata/__tests__/objectBrowserRowsCache.spec.ts@@ -1,6 +1,6 @@import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";import type { ObjectBrowserRow } from "@/lib/table/objectBrowserRows";-import { cacheObjectBrowserRows, clearObjectBrowserRowsCache, createObjectBrowserRowsCacheWriteToken, getCachedObjectBrowserRows, invalidateObjectBrowserRowsCache } from "@/lib/table/objectBrowserRowsCache";+import { cacheObjectBrowserRows, clearObjectBrowserRowsCache, createObjectBrowserRowsCacheWriteToken, getCachedObjectBrowserRows, getCachedObjectBrowserRowsForScaffold, invalidateObjectBrowserRowsCache } from "@/lib/table/objectBrowserRowsCache";const row: ObjectBrowserRow = {id: "table:users",@@ -127,4 +127,43 @@ describe("objectBrowserRowsCache", () => {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();+ });+ });});diff --git a/apps/desktop/src/lib/table/objectBrowserRowsCache.ts b/apps/desktop/src/lib/table/objectBrowserRowsCache.tsindex 3f89b8259f..2018598151 100644--- a/apps/desktop/src/lib/table/objectBrowserRowsCache.ts+++ b/apps/desktop/src/lib/table/objectBrowserRowsCache.ts@@ -78,6 +78,28 @@ export function getCachedObjectBrowserRows(scope: ObjectBrowserRowsCacheScope):return hit ? cloneRows(hit.value) : undefined;}+export interface ObjectBrowserRowsCacheHit {+ rows: ObjectBrowserRow[];+ stale: boolean;+ ageMs: number;+ cachedAt: number;+}++/**+ * Reads the cached rows for a scope as a **scaffold**, allowing stale entries+ * (beyond the TTL) to be surfaced and refreshed in the background. This never+ * adds a new cache entry or expands capacity — a stale hit is the same Map entry+ * the TTL would otherwise refuse to return, only now with its freshness metadata.+ *+ * Carries `stale`/`ageMs`/`cachedAt` so the caller can decide: keep an entry+ * under TTL as-is, or present it immediately then revalidate in the background.+ */+export function getCachedObjectBrowserRowsForScaffold(scope: ObjectBrowserRowsCacheScope): ObjectBrowserRowsCacheHit | undefined {+ const hit = objectBrowserRowsCache.get(objectBrowserRowsScope(scope), { allowStale: true });+ if (!hit) return undefined;+ return { rows: cloneRows(hit.value), stale: hit.stale, ageMs: hit.ageMs, cachedAt: hit.cachedAt };+}+export function createObjectBrowserRowsCacheWriteToken(scope: ObjectBrowserRowsCacheScope): ObjectBrowserRowsCacheWriteToken {const frozenScope = Object.freeze({ ...scope });return Object.freeze({ generation: objectBrowserRowsCacheGeneration(frozenScope).generation, scope: frozenScope });