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 { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
getTableDdl: vi.fn(),
getTableDisplayDdl: vi.fn(),
saveSchemaCache: vi.fn(),
loadSchemaCache: vi.fn(),
deleteSchemaCachePrefix: vi.fn(),
persisted: new Map<string, unknown>(),
}));
vi.mock("@/lib/backend/api", () => mocks);
import { cancelObjectDdlLoadsForConnection, getObjectDdlCacheDebugStateForTests, invalidateObjectDdl, invalidateObjectDdlCache, loadObjectDdl, objectDdlCacheKey } from "@/lib/metadata/objectDdlCache";
import { isObjectCacheInvalidationError } from "@/lib/metadata/objectCacheInvalidationError";
import { clearMetadataRuntimeCache } from "@/lib/metadata/metadataRuntimeCache";
const request = { connectionId: "c1", database: "app", schema: "public", tableName: "users", catalog: "analytics" } as const;
describe("objectDdlCache", () => {
it("keeps independent-index DDL separate from the original cached source", async () => {
mocks.getTableDisplayDdl.mockResolvedValueOnce("original").mockResolvedValueOnce("independent");
const separate = { ...request, separateIndexes: true };
expect(objectDdlCacheKey(separate)).not.toBe(objectDdlCacheKey(request));
await expect(loadObjectDdl(request)).resolves.toMatchObject({ ddl: "original", cacheStatus: "remote" });
await expect(loadObjectDdl(separate)).resolves.toMatchObject({ ddl: "independent", cacheStatus: "remote" });
expect(mocks.getTableDisplayDdl.mock.calls[1]).toEqual(["c1", "app", "public", "users", undefined, "analytics", true, undefined]);
await expect(loadObjectDdl(request)).resolves.toMatchObject({ ddl: "original", cacheStatus: "memory" });
await invalidateObjectDdlCache({ connectionId: "c1", database: "app", schema: "public", tableName: "users" });
mocks.getTableDisplayDdl.mockRejectedValueOnce(new Error("supporting index unavailable"));
await expect(loadObjectDdl(separate)).rejects.toThrow("supporting index unavailable");
mocks.getTableDisplayDdl.mockResolvedValueOnce("fresh original");
await expect(loadObjectDdl(request)).resolves.toMatchObject({ ddl: "fresh original", cacheStatus: "remote" });
});
it("isolates an explicit owner from the same service fallback and invalidates both", async () => {
const fallback = { ...request, schema: request.database, separateIndexes: true };
const explicit = { ...fallback, explicitOwner: request.database };
expect(objectDdlCacheKey(explicit)).not.toBe(objectDdlCacheKey(fallback));
mocks.getTableDisplayDdl.mockResolvedValueOnce("explicit").mockRejectedValueOnce(new Error("ambiguous service"));
await expect(loadObjectDdl(explicit)).resolves.toMatchObject({ ddl: "explicit", cacheStatus: "remote" });
expect(mocks.getTableDisplayDdl).toHaveBeenLastCalledWith("c1", "app", "app", "users", undefined, "analytics", true, "app");
await expect(loadObjectDdl(fallback)).rejects.toThrow("ambiguous service");
await expect(loadObjectDdl(explicit)).resolves.toMatchObject({ cacheStatus: "memory" });
await invalidateObjectDdlCache({ connectionId: "c1", database: "app", schema: "app", tableName: "users" });
mocks.getTableDisplayDdl.mockResolvedValueOnce("fresh");
await expect(loadObjectDdl(explicit)).resolves.toMatchObject({ ddl: "fresh", cacheStatus: "remote" });
expect(mocks.getTableDdl).not.toHaveBeenCalled();
});
it.each(["remote", "disk"])("settles local waiting when cancellation retires a never-returning %s read", async (phase) => {
if (phase === "disk") mocks.loadSchemaCache.mockReturnValueOnce(new Promise(() => undefined));
mocks.getTableDisplayDdl.mockReturnValueOnce(new Promise(() => undefined));
let settled = false;
const result = loadObjectDdl(request).then(
() => {
settled = true;
},
() => {
settled = true;
},
);
await vi.waitFor(() => expect(phase === "remote" ? mocks.getTableDisplayDdl.mock.calls.length : getObjectDdlCacheDebugStateForTests().activeReads).toBe(1));
cancelObjectDdlLoadsForConnection(request.connectionId);
await vi.waitFor(() => expect(settled).toBe(true));
await result;
expect(getObjectDdlCacheDebugStateForTests().activeReads).toBe(0);
});
beforeEach(() => {
clearMetadataRuntimeCache();
vi.clearAllMocks();
mocks.getTableDisplayDdl.mockReset();
mocks.getTableDdl.mockReset();
mocks.persisted.clear();
mocks.loadSchemaCache.mockImplementation(async (cacheKey: string) => mocks.persisted.get(cacheKey) ?? null);
mocks.saveSchemaCache.mockImplementation(async (cacheKey: string, payload: unknown) => {
mocks.persisted.set(cacheKey, payload);
});
mocks.deleteSchemaCachePrefix.mockImplementation(async (prefix: string) => {
for (const cacheKey of mocks.persisted.keys()) {
if (cacheKey === prefix || cacheKey.startsWith(prefix)) mocks.persisted.delete(cacheKey);
}
});
});
it("returns persisted DDL without querying the database", async () => {
mocks.loadSchemaCache.mockResolvedValue({ version: 1, cachedAt: new Date().toISOString(), ddl: "CREATE TABLE users (id int)" });
await expect(loadObjectDdl(request)).resolves.toEqual({ ddl: "CREATE TABLE users (id int)", cacheStatus: "disk" });
expect(mocks.getTableDisplayDdl).not.toHaveBeenCalled();
});
it("keeps exact DDL separate and never trusts or persists an unverified process snapshot", async () => {
mocks.loadSchemaCache.mockResolvedValue({ version: 1, cachedAt: new Date().toISOString(), ddl: "legacy" });
await loadObjectDdl(request);
const exact = { ...request, schema: " Mixed ", tableName: " T(a) ", exactIdentity: true };
mocks.getTableDdl.mockResolvedValue("exact");
expect(objectDdlCacheKey(exact)).not.toBe(objectDdlCacheKey({ ...exact, exactIdentity: false }));
await expect(loadObjectDdl(exact)).resolves.toEqual({ ddl: "exact", cacheStatus: "remote" });
expect(mocks.getTableDdl).toHaveBeenCalledExactlyOnceWith("c1", "app", " Mixed ", " T(a) ", undefined, "analytics", false, true);
expect(mocks.loadSchemaCache).toHaveBeenCalledOnce();
expect(mocks.saveSchemaCache).not.toHaveBeenCalled();
cancelObjectDdlLoadsForConnection("c1");
mocks.getTableDdl.mockRejectedValueOnce(new Error("exact capability unavailable"));
await expect(loadObjectDdl(exact)).rejects.toThrow("exact capability unavailable");
});
it("backfills memory after a disk hit", async () => {
mocks.loadSchemaCache.mockResolvedValue({ version: 1, cachedAt: new Date().toISOString(), ddl: "CREATE TABLE users (id int)" });
await expect(loadObjectDdl(request)).resolves.toMatchObject({ cacheStatus: "disk" });
await expect(loadObjectDdl(request)).resolves.toMatchObject({ cacheStatus: "memory" });
expect(mocks.loadSchemaCache).toHaveBeenCalledTimes(1);
expect(mocks.getTableDisplayDdl).not.toHaveBeenCalled();
});
it("caches an empty DDL string in memory", async () => {
mocks.getTableDisplayDdl.mockResolvedValue("");
await expect(loadObjectDdl(request)).resolves.toEqual({ ddl: "", cacheStatus: "remote" });
await expect(loadObjectDdl(request)).resolves.toEqual({ ddl: "", cacheStatus: "memory" });
expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(1);
});
it("persists a remote cache miss", async () => {
mocks.getTableDisplayDdl.mockResolvedValue("CREATE TABLE users (id bigint)");
await expect(loadObjectDdl(request)).resolves.toEqual({ ddl: "CREATE TABLE users (id bigint)", cacheStatus: "remote" });
expect(mocks.saveSchemaCache).toHaveBeenCalledWith(objectDdlCacheKey(request), expect.objectContaining({ version: 1, ddl: "CREATE TABLE users (id bigint)" }));
});
it("does not wait for a slow SQLite write before returning the remote result", async () => {
let releaseWrite: () => void = () => {};
mocks.saveSchemaCache.mockReturnValue(
new Promise<void>((resolve) => {
releaseWrite = resolve;
}),
);
mocks.getTableDisplayDdl.mockResolvedValue("CREATE TABLE users (id bigint)");
await expect(loadObjectDdl(request)).resolves.toMatchObject({ ddl: "CREATE TABLE users (id bigint)", cacheStatus: "remote" });
expect(mocks.saveSchemaCache).toHaveBeenCalledTimes(1);
releaseWrite();
await Promise.resolve();
await Promise.resolve();
});
it("waits for a pending SQLite write before deleting an invalidated entry", async () => {
let releaseWrite: () => void = () => {};
mocks.saveSchemaCache.mockReturnValue(
new Promise<void>((resolve) => {
releaseWrite = resolve;
}),
);
mocks.getTableDisplayDdl.mockResolvedValue("stale ddl");
await loadObjectDdl(request);
const invalidation = invalidateObjectDdl(request);
await Promise.resolve();
expect(mocks.deleteSchemaCachePrefix).not.toHaveBeenCalledWith(objectDdlCacheKey(request));
releaseWrite();
await invalidation;
expect(mocks.deleteSchemaCachePrefix).toHaveBeenCalledWith(objectDdlCacheKey(request));
});
it("deduplicates concurrent remote loads", async () => {
let release: (ddl: string) => void = () => {};
mocks.getTableDisplayDdl.mockReturnValue(
new Promise<string>((resolve) => {
release = resolve;
}),
);
const first = loadObjectDdl(request);
const second = loadObjectDdl(request);
await vi.waitFor(() => expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(1));
release("CREATE TABLE users (id int)");
await expect(Promise.all([first, second])).resolves.toHaveLength(2);
});
it("force refresh bypasses disk and overwrites it", async () => {
mocks.loadSchemaCache.mockResolvedValue({ version: 1, cachedAt: new Date().toISOString(), ddl: "old ddl" });
mocks.getTableDisplayDdl.mockResolvedValue("new ddl");
await expect(loadObjectDdl(request, { force: true })).resolves.toEqual({ ddl: "new ddl", cacheStatus: "remote" });
expect(mocks.loadSchemaCache).not.toHaveBeenCalled();
expect(mocks.saveSchemaCache).toHaveBeenCalledWith(objectDdlCacheKey(request), expect.objectContaining({ ddl: "new ddl" }));
});
it("force refresh bypasses memory and replaces it", async () => {
mocks.getTableDisplayDdl.mockResolvedValueOnce("old ddl").mockResolvedValueOnce("new ddl");
await expect(loadObjectDdl(request)).resolves.toEqual({ ddl: "old ddl", cacheStatus: "remote" });
await expect(loadObjectDdl(request, { force: true })).resolves.toEqual({ ddl: "new ddl", cacheStatus: "remote" });
await expect(loadObjectDdl(request)).resolves.toEqual({ ddl: "new ddl", cacheStatus: "memory" });
expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(2);
});
it("ignores an expired persisted DDL", async () => {
mocks.loadSchemaCache.mockResolvedValue({ version: 1, cachedAt: new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString(), ddl: "stale ddl" });
mocks.getTableDisplayDdl.mockResolvedValue("fresh ddl");
await expect(loadObjectDdl(request)).resolves.toEqual({ ddl: "fresh ddl", cacheStatus: "remote" });
expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(1);
});
it("deletes the exact persisted entry", async () => {
await invalidateObjectDdl(request);
expect(mocks.deleteSchemaCachePrefix).toHaveBeenCalledWith(objectDdlCacheKey(request));
});
it("reloads from the database after table-level persisted cache invalidation", async () => {
mocks.getTableDisplayDdl.mockResolvedValueOnce("old ddl").mockResolvedValueOnce("new ddl");
await expect(loadObjectDdl(request)).resolves.toEqual({ ddl: "old ddl", cacheStatus: "remote" });
await invalidateObjectDdlCache({ connectionId: request.connectionId, database: request.database, schema: request.schema, tableName: request.tableName });
await expect(loadObjectDdl(request)).resolves.toEqual({ ddl: "new ddl", cacheStatus: "remote" });
expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(2);
});
it("does not persist an in-flight result across invalidation", async () => {
let release: (ddl: string) => void = () => {};
mocks.getTableDisplayDdl.mockReturnValue(
new Promise<string>((resolve) => {
release = resolve;
}),
);
const load = loadObjectDdl(request);
await vi.waitFor(() => expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(1));
await invalidateObjectDdlCache({ connectionId: request.connectionId, database: request.database, schema: request.schema });
release("stale ddl");
await expect(load).resolves.toEqual({ ddl: "stale ddl", cacheStatus: "remote" });
expect(mocks.saveSchemaCache).not.toHaveBeenCalled();
});
it("does not resurrect a stale disk result when invalidated during the read", async () => {
let releaseDiskRead: (value: unknown) => void = () => {};
mocks.loadSchemaCache.mockReturnValueOnce(
new Promise((resolve) => {
releaseDiskRead = resolve;
}),
);
mocks.getTableDisplayDdl.mockResolvedValue("fresh ddl");
const load = loadObjectDdl(request);
await vi.waitFor(() => expect(mocks.loadSchemaCache).toHaveBeenCalledTimes(1));
const invalidation = invalidateObjectDdl(request);
releaseDiskRead({ version: 1, cachedAt: new Date().toISOString(), ddl: "stale ddl" });
await expect(load).resolves.toEqual({ ddl: "fresh ddl", cacheStatus: "remote" });
await invalidation;
expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(1);
expect(mocks.saveSchemaCache).toHaveBeenCalledWith(objectDdlCacheKey(request), expect.objectContaining({ ddl: "fresh ddl" }));
});
it("refreshing object B does not invalidate object A's concurrent disk read", async () => {
const requestA = { ...request, tableName: "accounts" };
const requestB = { ...request, tableName: "billing" };
let releaseA: (value: unknown) => void = () => {};
let releaseB: (value: unknown) => void = () => {};
mocks.loadSchemaCache.mockImplementation((cacheKey: string) => {
return new Promise((resolve) => {
if (cacheKey === objectDdlCacheKey(requestA)) releaseA = resolve;
if (cacheKey === objectDdlCacheKey(requestB)) releaseB = resolve;
});
});
mocks.getTableDisplayDdl.mockImplementation(async (_connectionId: string, _database: string, _schema: string, tableName: string) => `remote ${tableName}`);
const loadA = loadObjectDdl(requestA);
const loadB = loadObjectDdl(requestB);
await vi.waitFor(() => expect(mocks.loadSchemaCache).toHaveBeenCalledTimes(2));
const invalidation = invalidateObjectDdl(requestB);
releaseA({ version: 1, cachedAt: new Date().toISOString(), ddl: "cached accounts" });
releaseB({ version: 1, cachedAt: new Date().toISOString(), ddl: "stale billing" });
await expect(loadA).resolves.toEqual({ ddl: "cached accounts", cacheStatus: "disk" });
await expect(loadB).resolves.toEqual({ ddl: "remote billing", cacheStatus: "remote" });
await invalidation;
expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(1);
});
it("reclaims invalidation state after long-running multi-object refreshes", async () => {
for (let index = 0; index < 2_000; index += 1) {
await invalidateObjectDdlCache({ ...request, tableName: `history_${index}` });
}
expect(getObjectDdlCacheDebugStateForTests()).toEqual({ activeReads: 0 });
});
it("makes a concurrent normal read wait for a force refresh", async () => {
mocks.getTableDisplayDdl.mockResolvedValueOnce("old ddl");
await loadObjectDdl(request);
let releaseRemote: (value: string) => void = () => {};
mocks.getTableDisplayDdl.mockReturnValueOnce(
new Promise((resolve) => {
releaseRemote = resolve;
}),
);
const force = loadObjectDdl(request, { force: true });
const normal = loadObjectDdl(request);
await vi.waitFor(() => expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(2));
releaseRemote("new ddl");
await expect(Promise.all([force, normal])).resolves.toEqual([
{ ddl: "new ddl", cacheStatus: "remote" },
{ ddl: "new ddl", cacheStatus: "remote" },
]);
expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(2);
});
it("cancels an old connection load without repopulating the new session cache", async () => {
let releaseOld: (value: string) => void = () => {};
mocks.getTableDisplayDdl.mockReturnValueOnce(
new Promise((resolve) => {
releaseOld = resolve;
}),
);
const oldLoad = loadObjectDdl(request);
await vi.waitFor(() => expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(1));
cancelObjectDdlLoadsForConnection(request.connectionId);
releaseOld("old session ddl");
await expect(oldLoad).rejects.toThrow("Metadata waiting cancelled locally.");
mocks.getTableDisplayDdl.mockResolvedValueOnce("new session ddl");
await expect(loadObjectDdl(request)).resolves.toMatchObject({ ddl: "new session ddl", cacheStatus: "remote" });
expect(mocks.getTableDisplayDdl).toHaveBeenCalledTimes(2);
expect(mocks.deleteSchemaCachePrefix).not.toHaveBeenCalledWith("object-ddl:v1:c1:");
});
describe("strict connection-level invalidation", () => {
const connectionMatch = { connectionId: "c1" };
it.each(["object-ddl:v1:c1:", "object-meta:v1:c1:"])("waits for the other namespace when %s fails", async (failedPrefix) => {
let release!: () => void;
const pending = new Promise<void>((resolve) => {
release = resolve;
});
mocks.deleteSchemaCachePrefix.mockImplementation((prefix: string) => (prefix === failedPrefix ? Promise.reject(new Error("locked")) : pending));
let settled = false;
const outcome = invalidateObjectDdlCache(connectionMatch, { strict: true }).then(
() => {
settled = true;
return undefined;
},
(error: unknown) => {
settled = true;
return error;
},
);
await vi.waitFor(() => expect(mocks.deleteSchemaCachePrefix).toHaveBeenCalledTimes(2));
// Drain the rejection handlers, without releasing the other deletion.
await new Promise((resolve) => setTimeout(resolve, 0));
expect(settled).toBe(false);
release();
const failure = await outcome;
expect(isObjectCacheInvalidationError(failure)).toBe(true);
expect(failure).toMatchObject({ scope: failedPrefix, message: "locked" });
});
function objectPrefixes(): string[] {
return mocks.deleteSchemaCachePrefix.mock.calls.map(([prefix]) => prefix as string);
}
function rejectAllDeletions(error: Error) {
let rejectGate: (reason: Error) => void = () => {};
const gate = new Promise<void>((_resolve, reject) => {
rejectGate = reject;
});
mocks.deleteSchemaCachePrefix.mockImplementation(() =>
gate.then(
() => undefined,
() => {
throw error;
},
),
);
return () => rejectGate(error);
}
it("rejects with a marked object cache error when the persisted deletion fails", async () => {
mocks.deleteSchemaCachePrefix.mockRejectedValue(new Error("sqlite locked"));
const failure = await invalidateObjectDdlCache(connectionMatch, { strict: true }).then(
() => undefined,
(error: unknown) => error,
);
expect(failure).toBeInstanceOf(Error);
expect(isObjectCacheInvalidationError(failure)).toBe(true);
expect((failure as Error).message).toBe("sqlite locked");
// Both the DDL and the object-metadata namespace deletions were attempted.
expect(objectPrefixes()).toContain("object-ddl:v1:c1:");
expect(objectPrefixes()).toContain("object-meta:v1:c1:");
});
it("keeps default invalidation best-effort when the persisted deletion fails", async () => {
mocks.deleteSchemaCachePrefix.mockRejectedValue(new Error("sqlite locked"));
await expect(invalidateObjectDdlCache(connectionMatch)).resolves.toBeUndefined();
expect(objectPrefixes()).toEqual(["object-ddl:v1:c1:", "object-meta:v1:c1:"]);
});
it("still rejects in strict mode when a deletion rejects without a reason", async () => {
// A bare Promise.reject() has reason undefined; settled status, not the
// reason's value, must decide failure.
mocks.deleteSchemaCachePrefix.mockRejectedValue(undefined as never);
const failure = await invalidateObjectDdlCache(connectionMatch, { strict: true }).then(
() => undefined,
(error: unknown) => error,
);
expect(isObjectCacheInvalidationError(failure)).toBe(true);
});
it("lets a strict call sharing a pending best-effort deletion observe the failure", async () => {
const failAll = rejectAllDeletions(new Error("disk full"));
const bestEffort = invalidateObjectDdlCache(connectionMatch);
const strict = invalidateObjectDdlCache(connectionMatch, { strict: true });
// The strict call must reuse the in-flight deletions instead of starting new ones.
await vi.waitFor(() => expect(objectPrefixes()).toEqual(["object-ddl:v1:c1:", "object-meta:v1:c1:"]));
failAll();
await expect(bestEffort).resolves.toBeUndefined();
const failure = await strict.then(
() => undefined,
(error: unknown) => error,
);
expect(isObjectCacheInvalidationError(failure)).toBe(true);
expect((failure as Error).message).toBe("disk full");
});
it("retries the persisted deletion on the next strict invalidation after a failure", async () => {
mocks.deleteSchemaCachePrefix.mockRejectedValueOnce(new Error("locked")).mockRejectedValueOnce(new Error("locked"));
await expect(invalidateObjectDdlCache(connectionMatch, { strict: true })).rejects.toThrow("locked");
await expect(invalidateObjectDdlCache(connectionMatch, { strict: true })).resolves.toBeUndefined();
const prefixes = objectPrefixes();
expect(prefixes.filter((prefix) => prefix === "object-ddl:v1:c1:")).toHaveLength(2);
expect(prefixes.filter((prefix) => prefix === "object-meta:v1:c1:")).toHaveLength(2);
});
it("keeps non-force reads working when a concurrent deletion fails", async () => {
const failAll = rejectAllDeletions(new Error("locked"));
mocks.getTableDisplayDdl.mockResolvedValue("fresh ddl");
const invalidation = invalidateObjectDdlCache({ connectionId: request.connectionId, database: request.database, schema: request.schema, tableName: request.tableName });
const read = loadObjectDdl(request);
failAll();
await expect(read).resolves.toEqual({ ddl: "fresh ddl", cacheStatus: "remote" });
await expect(invalidation).resolves.toBeUndefined();
});
it("force refresh proceeds when the persisted deletion fails", async () => {
mocks.deleteSchemaCachePrefix.mockRejectedValue(new Error("locked"));
mocks.getTableDisplayDdl.mockResolvedValue("new ddl");
await expect(loadObjectDdl(request, { force: true })).resolves.toEqual({ ddl: "new ddl", cacheStatus: "remote" });
});
it("keeps object-level invalidation best-effort when the deletion fails", async () => {
mocks.deleteSchemaCachePrefix.mockRejectedValue(new Error("locked"));
await expect(invalidateObjectDdl(request)).resolves.toBeUndefined();
});
it("encodes connection ids and isolates similar ids in persisted deletions", async () => {
mocks.persisted.set("object-ddl:v1:conn10:db:public:t::TABLE:", { version: 1, cachedAt: new Date().toISOString(), ddl: "conn10 ddl" });
await invalidateObjectDdlCache({ connectionId: "conn1" });
expect(objectPrefixes()).toContain("object-ddl:v1:conn1:");
expect(objectPrefixes()).toContain("object-meta:v1:conn1:");
expect([...mocks.persisted.keys()]).toContain("object-ddl:v1:conn10:db:public:t::TABLE:");
await invalidateObjectDdlCache({ connectionId: "a:b c%中" });
expect(mocks.deleteSchemaCachePrefix).toHaveBeenCalledWith("object-ddl:v1:a%3Ab%20c%25%E4%B8%AD:");
expect(mocks.deleteSchemaCachePrefix).toHaveBeenCalledWith("object-meta:v1:a%3Ab%20c%25%E4%B8%AD:");
});
it("strips NUL bytes from remote and cached DDL", async () => {
mocks.getTableDisplayDdl.mockResolvedValue("CREATE TABLE t (id int DEFAULT '2'\0\0);");
const remoteResult = await loadObjectDdl(request, { force: true });
expect(remoteResult.ddl).toBe("CREATE TABLE t (id int DEFAULT '2');");
expect(remoteResult.ddl).not.toContain("\0");
mocks.persisted.set(objectDdlCacheKey(request), {
version: 1,
cachedAt: new Date().toISOString(),
ddl: "CREATE TABLE t (name varchar DEFAULT ''\0\0);",
});
clearMetadataRuntimeCache();
const diskResult = await loadObjectDdl(request);
expect(diskResult.ddl).toBe("CREATE TABLE t (name varchar DEFAULT '');");
expect(diskResult.ddl).not.toContain("\0");
});
});
});