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 type { TransferOwnershipPreview, TransferRequest, OraclePackageTransferRequest } from "@/lib/backend/api";
import type { ConnectionConfig } from "@/types/database";
import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
import { confirmTransferWithProductionSafety, createTransferSubmission, rebuildUnavailableReason, resolveTransferStrategy, supportsTransferUpsert, transferStrategyOptions, type TransferPackageConfirmation } from "../transferStrategy";
function deferred<T>() {
let resolve!: (value: T) => void;
let reject!: (error: Error) => void;
const promise = new Promise<T>((resolvePromise, rejectPromise) => {
resolve = resolvePromise;
reject = rejectPromise;
});
return { promise, resolve, reject };
}
function request(overrides: Partial<TransferRequest> = {}): TransferRequest {
return {
transferId: "transfer-1",
sourceConnectionId: "source",
sourceDatabase: "app",
sourceSchema: "public",
targetConnectionId: "target",
targetDatabase: "warehouse",
targetSchema: "reporting",
tables: ["Orders"],
objects: [{ objectType: "TABLE", names: ["Orders"] }],
createTable: true,
content: "structureAndData",
mode: "append",
targetTableNameCase: "lower",
quoteTargetColumnNames: true,
ownershipPolicy: "preserve",
batchSize: 1000,
dropTargetBeforeCreate: true,
dropTargetConfirmed: false,
...overrides,
};
}
function preview(overrides: Partial<TransferOwnershipPreview> = {}): TransferOwnershipPreview {
return {
missingOwners: [],
targetOwner: "target_user",
rebuild: {
sql: 'ALTER TABLE "reporting"."orders" RENAME TO "orders__dbx_bak_123";\nCREATE TABLE "reporting"."orders" ("id" INTEGER);',
tables: [{ sourceTable: "Orders", targetTable: '"reporting"."orders"', backupTable: '"reporting"."orders__dbx_bak_123"' }],
},
...overrides,
};
}
describe("transfer strategies", () => {
it.each(["append", "overwrite", "upsert"] as const)("loads legacy %s plus rebuild as rebuild", (mode) => {
expect(resolveTransferStrategy({ mode, dropTargetBeforeCreate: true })).toBe("rebuild");
});
it.each([
["append", { mode: "append", dropTargetBeforeCreate: false }],
["overwrite", { mode: "overwrite", dropTargetBeforeCreate: false }],
["upsert", { mode: "upsert", dropTargetBeforeCreate: false }],
["rebuild", { mode: "append", dropTargetBeforeCreate: true }],
] as const)("maps %s to one backend strategy", (strategy, options) => {
expect(transferStrategyOptions(strategy)).toEqual(options);
expect(resolveTransferStrategy(options)).toBe(strategy);
});
it("defaults legacy tasks without strategy fields to append", () => {
expect(resolveTransferStrategy({})).toBe("append");
});
it("does not expose unimplemented DB2 or Xugu upsert or rebuild strategies", () => {
expect(supportsTransferUpsert("db2")).toBe(false);
expect(rebuildUnavailableReason("structureAndData", "db2")).toBe("unsupported");
expect(rebuildUnavailableReason("structureOnly", "db2")).toBe("unsupported");
expect(supportsTransferUpsert("postgres")).toBe(true);
expect(supportsTransferUpsert("mysql")).toBe(true);
expect(supportsTransferUpsert("xugu")).toBe(false);
expect(supportsTransferUpsert(undefined)).toBe(true);
});
it.each([
["dataOnly", "postgres", "dataOnly"],
["structureAndData", "mongodb", "unsupported"],
["structureOnly", "postgres", undefined],
["structureAndData", "sqlite", undefined],
["structureAndData", undefined, "unsupported"],
] as const)("explains rebuild availability for %s and %s", (content, type, reason) => {
expect(rebuildUnavailableReason(content, type)).toBe(reason);
});
});
describe("transfer submission", () => {
function packageOptions(): OraclePackageTransferRequest {
const endpoint = { connectionId: "source", database: "tenant", schema: "Source", databaseType: "oracle" as const, generation: 1 };
return {
input: {
source: { endpoint, state: "complete", enumerationComplete: true, objects: [], issues: [] },
target: { endpoint: { ...endpoint, connectionId: "target", schema: "Target" }, state: "complete", enumerationComplete: true, objects: [], issues: [] },
drafts: [{ identity: { owner: "Target", name: "Pkg.With.Dot😀", kind: "PACKAGE_BODY" }, action: "create", sql: "original target draft" }],
},
operationIds: ["original-id"],
};
}
it("freezes nested package drafts and original IDs before asynchronous preview", async () => {
const gate = deferred<TransferOwnershipPreview>();
let captured: TransferRequest | undefined;
const execute = vi.fn();
const submission = createTransferSubmission({
preview: async (value) => {
captured = value;
return gate.promise;
},
confirmOwnership: async () => "preserve",
confirm: async () => false,
execute,
});
const input = request({ oraclePackages: packageOptions() });
const pending = submission.start(input);
input.oraclePackages!.input!.drafts[0].sql = "late unreviewed text";
input.oraclePackages!.operationIds!.push("late-id");
expect(captured!.oraclePackages!.input!.drafts[0].sql).toBe("original target draft");
expect(captured!.oraclePackages!.operationIds).toEqual(["original-id"]);
expect(() => {
captured!.oraclePackages!.input!.drafts[0].sql = "mutation";
}).toThrow();
gate.resolve(preview());
await expect(pending).resolves.toBe(false);
expect(execute).not.toHaveBeenCalled();
});
it("accepts only explicit same-package companion selection and freezes the final reviewed approval", async () => {
const decision = deferred<TransferPackageConfirmation>();
const execute = vi.fn();
const initial = request({ objects: [{ objectType: "PACKAGE_BODY", names: ["Pkg.With.Dot😀"] }], oraclePackages: packageOptions() });
const confirm = vi.fn(() => decision.promise);
const submission = createTransferSubmission({ preview: async () => preview(), confirmOwnership: async () => "preserve", confirm, execute });
const pending = submission.start(initial);
await vi.waitFor(() => expect(confirm).toHaveBeenCalledOnce());
const reviewed = { objects: [...initial.objects, { objectType: "PACKAGE" as const, names: ["Pkg.With.Dot😀"] }], oraclePackages: { ...packageOptions(), operationIds: ["reviewed-body", "reviewed-spec"] } };
decision.resolve(reviewed);
await expect(pending).resolves.toBe(true);
reviewed.oraclePackages.operationIds.push("late-unapproved-id");
expect(execute).toHaveBeenCalledOnce();
const final = execute.mock.calls[0][0] as TransferRequest;
expect(final.targetConnectionId).toBe(initial.targetConnectionId);
expect(final.tables).toEqual(initial.tables);
expect(final.objects).toEqual(reviewed.objects);
expect(final.oraclePackages?.operationIds).toEqual(["reviewed-body", "reviewed-spec"]);
});
it.each([
[{ objectType: "PACKAGE_BODY" as const, names: ["Different"] }],
[{ objectType: "PACKAGE" as const, names: ["Pkg.With.Dot😀"] }],
[
{ objectType: "PACKAGE_BODY" as const, names: ["Pkg.With.Dot😀"] },
{ objectType: "VIEW" as const, names: ["unreviewed"] },
],
])("rejects package review that changes or omits the original scope: %j", async (...objects) => {
const execute = vi.fn();
const submission = createTransferSubmission({ preview: async () => preview(), confirmOwnership: async () => "preserve", confirm: async () => ({ objects, oraclePackages: packageOptions() }), execute });
await expect(submission.start(request({ objects: [{ objectType: "PACKAGE_BODY", names: ["Pkg.With.Dot😀"] }] }))).rejects.toThrow("TRANSFER_PACKAGE_REVIEW_SCOPE_CHANGED");
expect(execute).not.toHaveBeenCalled();
});
it("reviews backend SQL and executes the frozen request only after confirmation", async () => {
const decision = deferred<boolean>();
const reviewed: Array<{ request: TransferRequest; preview: TransferOwnershipPreview }> = [];
const executions: TransferRequest[] = [];
const previews: TransferRequest[] = [];
const submission = createTransferSubmission({
preview: async (value) => {
previews.push(value);
return preview();
},
confirmOwnership: async () => "preserve",
confirm: (value, plan) => {
reviewed.push({ request: value, preview: plan });
return decision.promise;
},
execute: (value) => {
executions.push(value);
},
});
const input = request({ mode: "upsert", dropTargetConfirmed: true });
const pending = submission.start(input);
input.targetDatabase = "changed";
input.tables.push("Unreviewed");
input.objects[0]!.names.push("Unreviewed");
await vi.waitFor(() => expect(reviewed).toHaveLength(1));
expect(previews[0]).toMatchObject({ transferId: "transfer-1", targetDatabase: "warehouse", mode: "append", tables: ["Orders"], objects: [{ objectType: "TABLE", names: ["Orders"] }], dropTargetConfirmed: false });
expect(() => previews[0]!.tables.push("Mutated")).toThrow();
expect(reviewed[0]?.preview.rebuild?.sql).toBe('ALTER TABLE "reporting"."orders" RENAME TO "orders__dbx_bak_123";\nCREATE TABLE "reporting"."orders" ("id" INTEGER);');
expect(executions).toEqual([]);
decision.resolve(true);
await expect(pending).resolves.toBe(true);
expect(executions).toEqual([{ ...previews[0], dropTargetConfirmed: true }]);
expect(previews[0]?.dropTargetConfirmed).toBe(false);
});
it("discards a preview after the form or dialog invalidates its submission", async () => {
const backend = deferred<TransferOwnershipPreview>();
const reviewed: TransferRequest[] = [];
const executions: TransferRequest[] = [];
const submission = createTransferSubmission({
preview: () => backend.promise,
confirmOwnership: async () => "preserve",
confirm: async (value) => {
reviewed.push(value);
return true;
},
execute: (value) => {
executions.push(value);
},
});
const pending = submission.start(request());
submission.cancel();
backend.resolve(preview({ missingOwners: ["old_owner"] }));
await expect(pending).resolves.toBe(false);
expect(reviewed).toEqual([]);
expect(executions).toEqual([]);
});
it("does not execute an older confirmation after a newer transfer starts", async () => {
const decision = deferred<boolean>();
const executions: TransferRequest[] = [];
let confirmationCount = 0;
const submission = createTransferSubmission({
preview: async () => preview(),
confirmOwnership: async () => "preserve",
confirm: async (value) => {
confirmationCount++;
return value.transferId === "old" ? decision.promise : true;
},
execute: (value) => {
executions.push(value);
},
});
const old = submission.start(request({ transferId: "old" }));
await vi.waitFor(() => expect(confirmationCount).toBe(1));
await expect(submission.start(request({ transferId: "new" }))).resolves.toBe(true);
decision.resolve(true);
await expect(old).resolves.toBe(false);
expect(executions.map((value) => value.transferId)).toEqual(["new"]);
});
it("re-previews a changed ownership policy with the same transfer ID before final confirmation", async () => {
const previews: TransferRequest[] = [];
const reviewed: TransferOwnershipPreview[] = [];
const executions: TransferRequest[] = [];
const submission = createTransferSubmission({
preview: async (value) => {
previews.push(value);
return preview({ missingOwners: ["old_owner"], rebuild: { ...preview().rebuild!, sql: value.ownershipPolicy === "reassignMissing" ? "REASSIGNED PLAN" : "ORIGINAL PLAN" } });
},
confirmOwnership: async () => "reassignMissing",
confirm: async (_value, plan) => {
reviewed.push(plan);
return true;
},
execute: (value) => {
executions.push(value);
},
});
await expect(submission.start(request())).resolves.toBe(true);
expect(previews.map((value) => [value.transferId, value.ownershipPolicy, value.dropTargetConfirmed])).toEqual([
["transfer-1", "preserve", false],
["transfer-1", "reassignMissing", false],
]);
expect(reviewed.map((value) => value.rebuild?.sql)).toEqual(["REASSIGNED PLAN"]);
expect(executions[0]?.ownershipPolicy).toBe("reassignMissing");
});
it("refuses rebuild execution when the backend does not provide a rebuild plan", async () => {
const executions: TransferRequest[] = [];
const submission = createTransferSubmission({
preview: async () => preview({ rebuild: undefined }),
confirmOwnership: async () => "preserve",
confirm: async () => true,
execute: (value) => {
executions.push(value);
},
});
await expect(submission.start(request())).rejects.toThrow("TRANSFER_REBUILD_PREVIEW_UNAVAILABLE");
expect(executions).toEqual([]);
});
it("does not surface errors from a cancelled preview", async () => {
const backend = deferred<TransferOwnershipPreview>();
const submission = createTransferSubmission({ preview: () => backend.promise, confirmOwnership: async () => null, confirm: async () => false, execute: () => undefined });
const pending = submission.start(request());
submission.cancel();
backend.reject(new Error("old connection failed"));
await expect(pending).resolves.toBe(false);
});
it.each(["append", "overwrite", "upsert"] as const)("keeps ordinary %s data-only requests free of rebuild authorization", async (mode) => {
const executions: TransferRequest[] = [];
const submission = createTransferSubmission({
preview: async () => {
throw new Error("Data-only must not load DDL preview");
},
confirmOwnership: async () => null,
confirm: async () => true,
execute: (value) => {
executions.push(value);
},
});
await submission.start(request({ content: "dataOnly", createTable: false, mode, dropTargetBeforeCreate: false, dropTargetConfirmed: true }));
expect(executions[0]).toMatchObject({ mode, content: "dataOnly", createTable: false, dropTargetBeforeCreate: false, dropTargetConfirmed: false });
});
});
describe("transfer production confirmation", () => {
beforeEach(() => setActivePinia(createPinia()));
function connection(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
return { id: "target", name: "Warehouse", db_type: "postgres", host: "localhost", port: 5432, username: "target_user", password: "", ...overrides };
}
it.each([{ is_production: true }, { production_databases: ["warehouse"] }])("uses one shared confirmation for production scope %j", async (scope) => {
let ordinaryConfirmations = 0;
const pending = confirmTransferWithProductionSafety({
request: request(),
connection: connection(scope),
reviewText: preview().rebuild!.sql,
source: "Data Transfer",
confirm: async () => {
ordinaryConfirmations++;
return true;
},
});
const store = useProductionSafetyStore();
expect(store.pending).toMatchObject({ scopeId: "transfer-1", database: "warehouse", connectionName: "Warehouse", sql: preview().rebuild!.sql });
expect(ordinaryConfirmations).toBe(0);
store.confirm();
await expect(pending).resolves.toBe(true);
expect(store.pending).toBeUndefined();
});
it("cancels a pending production confirmation with the transfer scope", async () => {
const pending = confirmTransferWithProductionSafety({ request: request(), connection: connection({ production_databases: ["warehouse"] }), reviewText: "PLAN", confirm: async () => true });
useProductionSafetyStore().cancelScope("transfer-1");
await expect(pending).resolves.toBe(false);
expect(useProductionSafetyStore().pending).toBeUndefined();
});
it("uses the transfer confirmation for a non-production target", async () => {
let ordinaryConfirmations = 0;
const result = await confirmTransferWithProductionSafety({
request: request(),
connection: connection(),
reviewText: "PLAN",
confirm: async () => {
ordinaryConfirmations++;
return false;
},
});
expect(result).toBe(false);
expect(ordinaryConfirmations).toBe(1);
expect(useProductionSafetyStore().pending).toBeUndefined();
});
});