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。

5.5 KB
Raw Blame
import assert from "node:assert/strict";
import { beforeEach, test, vi } from "vitest";
import type { ColumnInfo, IndexInfo } from "../../apps/desktop/src/types/database.ts";

function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (reason?: unknown) => void;
  const promise = new Promise<T>((res, rej) => {
    resolve = res;
    reject = rej;
  });
  return { promise, resolve, reject };
}

beforeEach(() => {
  vi.resetModules();
});

test("table metadata loader deduplicates equivalent in-flight requests and caches the result", async () => {
  const columnsGate = deferred<ColumnInfo[]>();
  const indexes: IndexInfo[] = [{ name: "users_pkey", columns: ["id"], is_unique: true, is_primary: true }];
  const getColumns = vi.fn(() => columnsGate.promise);
  const listIndexes = vi.fn().mockResolvedValue(indexes);
  vi.doMock("@/lib/backend/api", () => ({ getColumns, listIndexes }));

  const { clearTableMetadataCache, loadTableMetadata } = await import("../../apps/desktop/src/lib/metadata/tableMetadataCache.ts");
  clearTableMetadataCache();

  const request = {
    connectionId: "conn",
    database: "app",
    schema: "public",
    tableName: "users",
    tableType: "TABLE",
    databaseType: "postgres",
    driverProfile: "postgres",
  };
  const first = loadTableMetadata(request);
  const second = loadTableMetadata(request);
  await vi.waitFor(() => assert.equal(listIndexes.mock.calls.length, 1));
  assert.equal(getColumns.mock.calls.length, 1);

  columnsGate.resolve([
    {
      name: "id",
      data_type: "integer",
      is_nullable: false,
      column_default: null,
      is_primary_key: true,
      extra: null,
    },
  ]);

  const [firstResult, secondResult] = await Promise.all([first, second]);
  assert.deepEqual(firstResult.metadata.primaryKeys, ["id"]);
  assert.equal(secondResult.metadata.columns.length, 1);
  assert.equal(listIndexes.mock.calls.length, 1);

  const cached = await loadTableMetadata(request);
  assert.equal(cached.cacheStatus, "hit");
  assert.equal(getColumns.mock.calls.length, 1);
});

test("uses agent-reported visible schemas for Vastbase and Kingbase index lookups", async () => {
  const resolvedSchemas: Record<string, string> = {
    "vastbase-1": "tenant_b",
    "kingbase-1": "workflow_schema",
  };
  const getColumns = vi.fn(async (connectionId: string): Promise<ColumnInfo[]> => {
    const resolvedSchema = resolvedSchemas[connectionId];
    assert.ok(resolvedSchema);
    return [
      {
        name: "id",
        data_type: "bigint",
        resolved_schema: resolvedSchema,
        is_nullable: false,
        column_default: null,
        is_primary_key: true,
        extra: null,
      },
    ];
  });
  const listIndexes = vi.fn(async (): Promise<IndexInfo[]> => []);
  vi.doMock("@/lib/backend/api", () => ({ getColumns, listIndexes }));

  const { clearTableMetadataCache, loadTableColumns, loadTableMetadata } = await import("../../apps/desktop/src/lib/metadata/tableMetadataCache.ts");
  clearTableMetadataCache();

  const testCases = [
    { connectionId: "vastbase-1", databaseType: "vastbase", resolvedSchema: "tenant_b" },
    { connectionId: "kingbase-1", databaseType: "kingbase", resolvedSchema: "workflow_schema" },
  ] as const;
  for (const [index, testCase] of testCases.entries()) {
    const result = await loadTableMetadata({
      connectionId: testCase.connectionId,
      database: "app",
      schema: "",
      tableName: "users",
      tableType: "TABLE",
      databaseType: testCase.databaseType,
      driverProfile: testCase.databaseType,
    });

    assert.equal(result.metadata.schema, testCase.resolvedSchema);
    assert.equal(listIndexes.mock.calls[index]?.[2], testCase.resolvedSchema);

    const columnsResult = await loadTableColumns({
      connectionId: testCase.connectionId,
      database: "app",
      schema: "",
      tableName: "users",
      tableType: "TABLE",
      databaseType: testCase.databaseType,
      driverProfile: testCase.databaseType,
      force: true,
    });
    assert.equal(columnsResult.schema, testCase.resolvedSchema);
  }
  assert.equal(listIndexes.mock.calls.length, 2);
});

test("table metadata invalidation keeps unrelated schemas cached", async () => {
  const getColumns = vi.fn(
    async (_connectionId: string, _database: string, _schema: string, table: string): Promise<ColumnInfo[]> => [
      {
        name: `${table}_id`,
        data_type: "integer",
        is_nullable: false,
        column_default: null,
        is_primary_key: true,
        extra: null,
      },
    ],
  );
  const listIndexes = vi.fn(async (): Promise<IndexInfo[]> => []);
  vi.doMock("@/lib/backend/api", () => ({ getColumns, listIndexes }));

  const { clearTableMetadataCache, getCachedTableMetadata, invalidateTableMetadataCache, loadTableMetadata } = await import("../../apps/desktop/src/lib/metadata/tableMetadataCache.ts");
  clearTableMetadataCache();

  const publicRequest = {
    connectionId: "conn",
    database: "app",
    schema: "public",
    tableName: "users",
    tableType: "TABLE",
    databaseType: "postgres",
    driverProfile: "postgres",
  };
  const auditRequest = { ...publicRequest, schema: "audit", tableName: "audit_log" };

  await loadTableMetadata(publicRequest);
  await loadTableMetadata(auditRequest);
  assert.equal(getColumns.mock.calls.length, 2);

  assert.equal(invalidateTableMetadataCache({ connectionId: "conn", database: "app", schema: "public" }), 1);
  assert.equal(getCachedTableMetadata(publicRequest), undefined);
  assert.equal(getCachedTableMetadata(auditRequest)?.metadata.tableName, "audit_log");
});