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 { createPinia, setActivePinia } from "pinia";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { ACTIVE_TAB_STORAGE_KEY, OPEN_TABS_STORAGE_KEY } from "@/lib/app/openTabsPersistence";
function installLocalStorage() {
const data = new Map<string, string>();
vi.stubGlobal("localStorage", {
getItem: vi.fn((key: string) => data.get(key) ?? null),
setItem: vi.fn((key: string, value: string) => data.set(key, value)),
removeItem: vi.fn((key: string) => data.delete(key)),
});
return data;
}
describe("queryStore database open state", () => {
beforeEach(() => {
vi.resetModules();
vi.unstubAllGlobals();
installLocalStorage();
setActivePinia(createPinia());
});
it("tracks whether a connection database has open tabs", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const tabId = store.createTab("pg-1", "app", "query_1");
expect(store.isDatabaseOpen("pg-1", "app")).toBe(true);
expect(store.isDatabaseOpen("pg-1", "analytics")).toBe(false);
expect(store.isDatabaseOpen("pg-2", "app")).toBe(false);
store.updateDatabase(tabId, "analytics");
expect(store.isDatabaseOpen("pg-1", "app")).toBe(false);
expect(store.isDatabaseOpen("pg-1", "analytics")).toBe(true);
store.closeTab(tabId);
expect(store.isDatabaseOpen("pg-1", "analytics")).toBe(false);
}, 10_000);
it("reuses one database browser tab per connection", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const firstId = store.openDatabaseBrowser("pg-1");
const secondId = store.openDatabaseBrowser("pg-1");
const otherConnectionId = store.openDatabaseBrowser("pg-2");
expect(secondId).toBe(firstId);
expect(otherConnectionId).not.toBe(firstId);
expect(store.tabs.filter((tab) => tab.mode === "databases")).toHaveLength(2);
expect(store.tabs.find((tab) => tab.id === firstId)).toMatchObject({ connectionId: "pg-1", database: "", mode: "databases" });
});
it.each(["create", "view"] as const)("does not reuse a consumed Schema index %s navigation request id", async (kind) => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const request = kind === "create" ? { create: true } : { view: { schema: "APP", name: "IX_A", parentSchema: "OTHER", parentName: "T" } };
const id = store.openObjectBrowser("ob", "service", "APP", undefined, undefined, false, "indexes", undefined, request);
const state = store.tabs.find((tab) => tab.id === id)!.objectBrowser!;
const firstRequest = kind === "create" ? state.indexCreateRequestId : state.initialViewRequestId;
state.indexCreateRequestId = undefined;
state.initialViewRequestId = undefined;
state.initialViewTarget = undefined;
expect(store.openObjectBrowser("ob", "service", "APP", undefined, undefined, false, "indexes", undefined, request)).toBe(id);
const next = store.tabs.find((tab) => tab.id === id)!.objectBrowser!;
expect(kind === "create" ? next.indexCreateRequestId : next.initialViewRequestId).toBeGreaterThan(firstRequest!);
});
it.each(["create", "view"] as const)("supersedes an unconsumed Schema index %s request in the reused tab", async (first) => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const view = { schema: "APP", name: "IX_A", parentSchema: "OTHER", parentName: "T" };
const id = store.openObjectBrowser("ob", "service", "APP", undefined, undefined, false, "indexes", undefined, first === "create" ? { create: true } : { view });
const sequence = store.tabs.find((tab) => tab.id === id)!.objectBrowser!.indexRequestSequence!;
expect(store.openObjectBrowser("ob", "service", "APP", undefined, undefined, false, "indexes", undefined, first === "create" ? { view } : { create: true })).toBe(id);
const state = store.tabs.find((tab) => tab.id === id)!.objectBrowser!;
expect(state.indexRequestSequence).toBeGreaterThan(sequence);
expect(state.indexCreateRequestId).toBe(first === "view" ? state.indexRequestSequence : undefined);
expect(state.initialViewRequestId).toBe(first === "create" ? state.indexRequestSequence : undefined);
expect(state.initialViewTarget).toEqual(first === "create" ? view : undefined);
expect(store.tabs.filter((tab) => tab.mode === "objects")).toHaveLength(1);
});
it("retargets a connection-scoped driver workspace to a database branch", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const firstId = store.openDriverProfileWorkspace("dolt-1", "inventory", "Version Control", "dolt-version-control", "connection");
const branchId = store.openDriverProfileWorkspace("dolt-1", "analytics", "Version Control", "dolt-version-control", "connection", "feature/orders");
expect(branchId).toBe(firstId);
expect(store.tabs.find((tab) => tab.id === firstId)).toMatchObject({
database: "analytics",
workspaceBranch: "feature/orders",
mode: "dolt-version-control",
});
});
it("keeps database-scoped driver workspaces isolated", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const inventoryId = store.openDriverProfileWorkspace("profile-1", "inventory", "Workspace", "dolt-version-control", "database");
const analyticsId = store.openDriverProfileWorkspace("profile-1", "analytics", "Workspace", "dolt-version-control", "database");
expect(analyticsId).not.toBe(inventoryId);
expect(store.tabs.filter((tab) => tab.mode === "dolt-version-control")).toHaveLength(2);
});
it("keeps object browser filter, search, and viewport per tab", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const tabId = store.openObjectBrowser("pg-1", "app", "public");
store.updateObjectBrowserFilter(tabId, "views");
store.updateObjectBrowserSearch(tabId, "orders");
store.updateObjectBrowserViewport(tabId, { scrollTop: 340, viewMode: "list" });
const tab = store.tabs.find((item) => item.id === tabId);
expect(tab?.objectBrowser?.filter).toBe("views");
expect(tab?.objectBrowser?.searchQuery).toBe("orders");
expect(tab?.objectBrowser?.viewport).toEqual({ scrollTop: 340, viewMode: "list" });
const otherTabId = store.createTab("pg-1", "app", "query");
store.switchTab(otherTabId);
store.switchTab(tabId);
expect(store.tabs.find((item) => item.id === tabId)?.objectBrowser?.filter).toBe("views");
expect(store.tabs.find((item) => item.id === tabId)?.objectBrowser?.searchQuery).toBe("orders");
store.updateSchema(tabId, "archive");
expect(tab?.objectBrowser?.schema).toBe("archive");
// The keyword intentionally survives a schema switch: the mounted browser keeps its local search too.
expect(tab?.objectBrowser?.searchQuery).toBe("orders");
expect(tab?.objectBrowser?.filter).toBeUndefined();
expect(tab?.objectBrowser?.viewport).toBeUndefined();
});
it("keeps external catalog object browsers isolated", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const icebergTabId = store.openObjectBrowser("doris-1", "default", undefined, "iceberg_catalog");
const hiveTabId = store.openObjectBrowser("doris-1", "default", undefined, "hive_catalog");
expect(hiveTabId).not.toBe(icebergTabId);
expect(store.tabs.find((tab) => tab.id === icebergTabId)?.objectBrowser?.catalog).toBe("iceberg_catalog");
expect(store.tabs.find((tab) => tab.id === hiveTabId)?.objectBrowser?.catalog).toBe("hive_catalog");
expect(store.openObjectBrowser("doris-1", "default", undefined, "iceberg_catalog")).toBe(icebergTabId);
});
it("keeps external catalog structure editors isolated", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const icebergTabId = store.openTableStructure("doris-1", "sales", undefined, "orders", undefined, undefined, "iceberg_catalog");
const hiveTabId = store.openTableStructure("doris-1", "sales", undefined, "orders", undefined, undefined, "hive_catalog");
expect(hiveTabId).not.toBe(icebergTabId);
expect(store.tabs.find((tab) => tab.id === icebergTabId)?.catalog).toBe("iceberg_catalog");
expect(store.tabs.find((tab) => tab.id === hiveTabId)?.catalog).toBe("hive_catalog");
expect(store.openTableStructure("doris-1", "sales", undefined, "orders", undefined, undefined, "iceberg_catalog")).toBe(icebergTabId);
});
it("keeps same-name structure editors in different schemas isolated", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const publicTabId = store.openTableStructure("pg-1", "app", "public", "users");
const archiveTabId = store.openTableStructure("pg-1", "app", "archive", "users");
expect(archiveTabId).not.toBe(publicTabId);
expect(store.tabs.filter((tab) => tab.mode === "structure")).toHaveLength(2);
expect(store.tabs.find((tab) => tab.id === publicTabId)?.schema).toBe("public");
expect(store.tabs.find((tab) => tab.id === archiveTabId)?.schema).toBe("archive");
expect(store.openTableStructure("pg-1", "app", "public", "users")).toBe(publicTabId);
expect(store.activeTabId).toBe(publicTabId);
});
it("preserves case-sensitive schema and table identities", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const quotedTabId = store.openTableStructure("pg-1", "app", "Sales", "Users");
const schemaCaseTabId = store.openTableStructure("pg-1", "app", "sales", "Users");
const tableCaseTabId = store.openTableStructure("pg-1", "app", "Sales", "users");
expect(new Set([quotedTabId, schemaCaseTabId, tableCaseTabId])).toHaveLength(3);
expect(store.openTableStructure("pg-1", "app", "Sales", "Users")).toBe(quotedTabId);
});
it("never upgrades a legacy structure draft to an exact dictionary target", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const legacy = store.openTableStructure("ob", "service", " Mixed ", " T(a) ");
const oldTab = store.tabs.find((tab) => tab.id === legacy)!;
oldTab.structureDraft = { dirty: true, newTableName: "untouched" } as NonNullable<typeof oldTab.structureDraft>;
const exact = store.openTableStructure("ob", "service", " Mixed ", " T(a) ", "indexes", { kind: "index", name: " Ix(a) " }, undefined, "table", true);
expect(exact).not.toBe(legacy);
expect(oldTab.structureDraft.newTableName).toBe("untouched");
expect(oldTab.structureExactIdentity).toBeUndefined();
expect(store.tabs.find((tab) => tab.id === exact)).toMatchObject({ schema: " Mixed ", structureTableName: " T(a) ", structureExactIdentity: true });
expect(store.openTableStructure("ob", "service", " Mixed ", " T(a) ", "indexes", { kind: "index", name: "Ix(a)" }, undefined, "table", true)).toBe(exact);
expect(store.openTableStructure("ob", "service", "Mixed", "T(a)", "indexes", undefined, undefined, "table", true)).not.toBe(exact);
});
it("isolates exact structure refreshes by raw identity, catalog and metadata mode", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
store.invalidateTableStructure("ob", "service", " Mixed ", " T(a) ", true, "catalog");
expect(store.tableStructureRefreshVersion("ob", "service", " Mixed ", " T(a) ", true, "catalog")).toBe(1);
expect(store.tableStructureRefreshVersion("ob", "service", " Mixed ", " T(a) ")).toBe(0);
expect(store.tableStructureRefreshVersion("ob", "service", " Mixed ", " T(a) ", true, "other")).toBe(0);
expect(store.tableStructureRefreshVersion("ob", "service", " mixed ", " T(a) ", true, "catalog")).toBe(0);
expect(store.tableStructureRefreshVersion("ob", "service", "Mixed", "T(a)", true, "catalog")).toBe(0);
store.invalidateTableStructure("ob", "service", "APP", "TABLE");
expect(store.tableStructureRefreshVersion("ob", "service", "app", "table")).toBe(1);
});
it("retains explicit create-index requests without inventing an existing index name", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const create = { kind: "index", name: "", action: "create" } as const;
const id = store.openTableStructure("ob", "service", "APP", "Items", undefined, create, undefined, "table", true);
expect(store.tabs.find((tab) => tab.id === id)).toMatchObject({ structureInitialTarget: create, structureInitialTabRequestId: 1 });
store.openTableStructure("ob", "service", "APP", "Items", undefined, create, undefined, "table", true);
expect(store.tabs.find((tab) => tab.id === id)).toMatchObject({ structureInitialTarget: create, structureInitialTabRequestId: 2 });
});
it("retains raw index owner requests while reusing an exact parent tab with dirty drafts", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const initial = { kind: "index", name: " Ix(a) ", owner: " Owner " } as const;
const id = store.openTableStructure("ob", "service", " Owner ", " T(a) ", "indexes", initial, undefined, "table", true);
const tab = store.tabs.find((item) => item.id === id)!;
tab.structureDraft = { dirty: true, newTableName: "untouched" } as NonNullable<typeof tab.structureDraft>;
expect(tab.structureInitialTarget).toEqual(initial);
const deletion = { ...initial, action: "delete" } as const;
expect(store.openTableStructure("ob", "service", " Owner ", " T(a) ", "indexes", deletion, undefined, "table", true)).toBe(id);
expect(tab.structureInitialTarget).toEqual(deletion);
expect(tab.structureDraft.newTableName).toBe("untouched");
});
it("reuses only matching schema-less structure targets", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const schemaLessTabId = store.openTableStructure("mysql-1", "app", undefined, "users");
const reusedTabId = store.openTableStructure("mysql-1", "app", undefined, "users", "columns", { kind: "column", name: "id" });
const explicitSchemaTabId = store.openTableStructure("mysql-1", "app", "public", "users");
const firstCreateTabId = store.openTableStructure("mysql-1", "app", undefined, "");
const secondCreateTabId = store.openTableStructure("mysql-1", "app", undefined, "");
expect(reusedTabId).toBe(schemaLessTabId);
expect(store.tabs.find((tab) => tab.id === schemaLessTabId)).toMatchObject({
schema: undefined,
structureInitialTab: "columns",
structureInitialTabRequestId: 1,
structureInitialTarget: { kind: "column", name: "id" },
});
expect(explicitSchemaTabId).not.toBe(schemaLessTabId);
expect(secondCreateTabId).not.toBe(firstCreateTabId);
});
it("clears the catalog when changing a query tab connection", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const tabId = store.createTab("doris-1", "sales", "Query", "query", undefined, undefined, "hive_catalog");
const tab = store.tabs.find((item) => item.id === tabId)!;
store.updateConnection(tabId, "doris-2", "analytics");
expect(tab.connectionId).toBe("doris-2");
expect(tab.catalog).toBeUndefined();
expect(tab.database).toBe("analytics");
expect(tab.schema).toBeUndefined();
});
it("closes data and structure tabs for a dropped table object", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const queryId = store.createTab("pg-1", "app", "Query", "query", "public");
const dataId = store.createTab("pg-1", "app", "users", "data", "public");
store.setTableMeta(dataId, {
schema: "public",
tableName: "users",
tableType: "TABLE",
columns: [],
primaryKeys: [],
});
const otherSchemaDataId = store.createTab("pg-1", "app", "users", "data", "archive");
store.setTableMeta(otherSchemaDataId, {
schema: "archive",
tableName: "users",
tableType: "TABLE",
columns: [],
primaryKeys: [],
});
const otherConnectionDataId = store.createTab("pg-2", "app", "users", "data", "public");
store.setTableMeta(otherConnectionDataId, {
schema: "public",
tableName: "users",
tableType: "TABLE",
columns: [],
primaryKeys: [],
});
const structureId = store.openTableStructure("pg-1", "app", "public", "users");
store.activeTabId = dataId;
store.closeDroppedTableObjectTabs({
connectionId: "pg-1",
database: "app",
schema: "public",
name: "users",
objectType: "TABLE",
});
expect(store.tabs.some((tab) => tab.id === dataId)).toBe(false);
expect(store.tabs.some((tab) => tab.id === structureId)).toBe(false);
expect(store.tabs.some((tab) => tab.id === otherSchemaDataId)).toBe(true);
expect(store.tabs.some((tab) => tab.id === otherConnectionDataId)).toBe(true);
expect(store.tabs.some((tab) => tab.id === queryId)).toBe(true);
expect(store.activeTabId).not.toBe(dataId);
});
it("closes data tabs but keeps structure tabs for dropped views", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const dataId = store.createTab("pg-1", "app", "report_view", "data", "public");
store.setTableMeta(dataId, {
schema: "public",
tableName: "report_view",
tableType: "VIEW",
columns: [],
primaryKeys: [],
});
const structureId = store.openTableStructure("pg-1", "app", "public", "report_view");
store.closeDroppedTableObjectTabs({
connectionId: "pg-1",
database: "app",
schema: "public",
name: "report_view",
objectType: "VIEW",
});
expect(store.tabs.some((tab) => tab.id === dataId)).toBe(false);
expect(store.tabs.some((tab) => tab.id === structureId)).toBe(true);
});
it("closes only the matching HBase table tab after deletion", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const deletedTableId = store.createTab("hbase-1", "metrics", "events", "hbase", undefined, "events");
const otherTableId = store.createTab("hbase-1", "metrics", "archive", "hbase", undefined, "archive");
const otherNamespaceId = store.createTab("hbase-1", "default", "events", "hbase", undefined, "events");
store.closeDroppedTableObjectTabs({
connectionId: "hbase-1",
database: "metrics",
name: "events",
objectType: "TABLE",
});
expect(store.tabs.some((tab) => tab.id === deletedTableId)).toBe(false);
expect(store.tabs.some((tab) => tab.id === otherTableId)).toBe(true);
expect(store.tabs.some((tab) => tab.id === otherNamespaceId)).toBe(true);
});
it("matches dropped table schema candidates", async () => {
const { useQueryStore } = await import("@/stores/queryStore");
const store = useQueryStore();
const dataId = store.createTab("pg-1", "app", "orders", "data", "app");
store.setTableMeta(dataId, {
schema: "app",
tableName: "orders",
tableType: "TABLE",
columns: [],
primaryKeys: [],
});
const structureId = store.openTableStructure("pg-1", "app", undefined, "orders");
store.closeDroppedTableObjectTabs({
connectionId: "pg-1",
database: "app",
schema: "app",
schemaCandidates: [undefined, "app"],
name: "orders",
objectType: "TABLE",
});
expect(store.tabs.some((tab) => tab.id === dataId)).toBe(false);
expect(store.tabs.some((tab) => tab.id === structureId)).toBe(false);
});
it("does not restore open tabs when launch restore mode is none", async () => {
const persistedTabs = JSON.stringify([
{
id: "tab-1",
title: "Query 1",
connectionId: "pg-1",
database: "app",
sql: "select 1",
},
]);
vi.resetModules();
vi.unstubAllGlobals();
const storage = installLocalStorage();
storage.set("dbx-editor-settings", JSON.stringify({ openTabsRestoreMode: "none" }));
storage.set("dbx-app-state:open_tabs", JSON.stringify({ tabs: JSON.parse(persistedTabs), activeTabId: "tab-1" }));
storage.set(OPEN_TABS_STORAGE_KEY, persistedTabs);
storage.set(ACTIVE_TAB_STORAGE_KEY, "tab-1");
setActivePinia(createPinia());
const { useSettingsStore } = await import("@/stores/settingsStore");
const { useQueryStore } = await import("@/stores/queryStore");
await useSettingsStore().initEditorSettings();
const store = useQueryStore();
await store.initOpenTabs();
expect(store.tabs).toEqual([]);
expect(store.activeTabId).toBeNull();
expect(storage.get(OPEN_TABS_STORAGE_KEY)).toBeUndefined();
expect(storage.get(ACTIVE_TAB_STORAGE_KEY)).toBeUndefined();
expect(JSON.parse(storage.get("dbx-app-state:open_tabs") ?? "{}")).toEqual({ tabs: [], activeTabId: null });
});
it("restores only pinned tabs when launch restore mode is pinned", async () => {
const persistedTabs = JSON.stringify([
{
id: "tab-1",
title: "Pinned",
connectionId: "pg-1",
database: "app",
sql: "select 1",
pinned: true,
},
{
id: "tab-2",
title: "Regular",
connectionId: "pg-1",
database: "app",
sql: "select 2",
},
]);
vi.resetModules();
vi.unstubAllGlobals();
const storage = installLocalStorage();
storage.set("dbx-editor-settings", JSON.stringify({ openTabsRestoreMode: "pinned" }));
storage.set(OPEN_TABS_STORAGE_KEY, persistedTabs);
storage.set(ACTIVE_TAB_STORAGE_KEY, "tab-2");
setActivePinia(createPinia());
const { useSettingsStore } = await import("@/stores/settingsStore");
const { useQueryStore } = await import("@/stores/queryStore");
await useSettingsStore().initEditorSettings();
const store = useQueryStore();
await store.initOpenTabs();
expect(store.tabs.map((tab) => tab.id)).toEqual(["tab-1"]);
expect(store.activeTabId).toBe("tab-1");
});
});