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 { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { ConnectionConfig, ObjectSource } from "@/types/database";
import type { BackendError } from "@/lib/backend/errorUtils";
const mocks = vi.hoisted(() => ({ source: vi.fn(), query: vi.fn(), objects: vi.fn(), unlockState: vi.fn(), prepareSql: vi.fn(), dropSql: vi.fn(), invoke: vi.fn() }));
vi.mock("@tauri-apps/api/core", () => ({ invoke: mocks.invoke }));
vi.mock("@/lib/backend/api", () => ({
getObjectSource: mocks.source,
executeQuery: mocks.query,
listObjects: mocks.objects,
prepareOracleTriggerSql: mocks.prepareSql,
buildDropObjectSql: mocks.dropSql,
connectionWriteUnlockState: mocks.unlockState,
deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
listInstalledAgents: vi.fn().mockResolvedValue([]),
}));
const target = { connectionId: "trigger-plan", database: "service", catalog: "container", owner: " Trigger Owner ", name: ' Tr"ig ', executionSchema: " Execution Owner " };
function source(enabled: boolean): ObjectSource {
return {
name: target.name,
schema: target.owner,
object_type: "TRIGGER",
source: "BEGIN :NEW.V := 7; END;",
editable: false,
trigger: {
name: target.name,
event: "UPDATE",
timing: "INSTEAD OF",
enabled,
valid: false,
oracle_metadata: {
contractVersion: 1,
identityMode: "exact",
engine: "oceanbase-oracle",
engineVersion: "4.2.5.7_107",
owner: target.owner,
name: target.name,
objectId: "9007199254740993",
lastDdlTime: "2026-10-21 08:00:00",
scope: "VIEW",
parent: { owner: " Parent Owner ", name: " View ", objectType: "VIEW" },
definition: { origin: "catalog-body", format: "body", complete: false },
errors: [{ sequence: 1, line: 3, position: 7, text: "Missing procedure" }],
reads: { identity: { state: "available" }, scope: { state: "available" }, parent: { state: "available" }, enabled: { state: "available" }, validity: { state: "available" }, definition: { state: "denied" }, errors: { state: "available" } },
},
},
};
}
beforeEach(async () => {
vi.resetModules();
vi.clearAllMocks();
mocks.source.mockReset();
mocks.query.mockReset();
mocks.prepareSql.mockReset();
mocks.dropSql.mockReset().mockResolvedValue('DROP TRIGGER " Trigger Owner "." Tr""ig ";');
mocks.unlockState.mockReset().mockResolvedValue(0);
const data = new Map<string, string>();
vi.stubGlobal("localStorage", { getItem: (key: string) => data.get(key) ?? null, setItem: (key: string, value: string) => data.set(key, value), removeItem: (key: string) => data.delete(key) });
setActivePinia(createPinia());
const { useConnectionStore } = await import("@/stores/connectionStore");
const store = useConnectionStore();
store.connections = [{ id: target.connectionId, name: "Trigger test", db_type: "oceanbase-oracle", username: " Execution Owner ", database: "service" } as ConnectionConfig];
store.connectedIds.add(target.connectionId);
mocks.query.mockResolvedValue({ columns: [], rows: [], affected_rows: 0, execution_time_ms: 1 });
});
describe("Oracle-family trigger action plans", () => {
afterEach(() => vi.unstubAllGlobals());
it.each([false, true])("preserves each trigger execution schema and the legacy statement's captured/default schema (explicit unset=%s)", async (explicitUnset) => {
const second = { ...target, owner: "Other.Owner", name: "OtherTrigger", executionSchema: "Other.Execution" };
const gone = new Set<string>();
const key = (owner: string, name: string) => JSON.stringify([owner, name]);
const quote = (name: string) => `"${name.replaceAll('"', '""')}"`;
mocks.source.mockImplementation(async (_id, _db, owner, name) => {
const raw = source(false);
raw.name = raw.trigger!.name = name;
raw.schema = raw.trigger!.oracle_metadata!.owner = owner;
raw.trigger!.oracle_metadata!.name = name;
raw.trigger!.oracle_metadata!.objectId = gone.has(key(owner, name)) ? null : `${owner}-physical-id`;
raw.trigger!.oracle_metadata!.reads.identity = { state: gone.has(key(owner, name)) ? "empty" : "available" };
return raw;
});
mocks.dropSql.mockImplementation(async (input) => `DROP TRIGGER ${quote(input.schema)}.${quote(input.name)};`);
mocks.query.mockImplementation(async (_id, _db, sql) => {
if (sql.startsWith("SELECT USER")) return { columns: ["SESSION_USER"], rows: [["Login.Owner"]] };
if (sql.includes("DBA_OBJECTS")) return { columns: ["OWNER", "OBJECT_NAME"], rows: [] };
if (sql.startsWith("SELECT")) return { columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[" Parent Owner ", " View ", "VIEW", "parent-id"]] };
for (const item of [target, second]) if (sql === `DROP TRIGGER ${quote(item.owner)}.${quote(item.name)};`) gone.add(key(item.owner, item.name));
return { columns: [], rows: [] };
});
const { prepareOracleTriggerPlan, prepareOracleTriggerDropBatchPlan, executeOracleTriggerDropBatchPlan } = await import("@/lib/database/oracleTriggerPlan");
const firstPlan = await prepareOracleTriggerPlan({ target, action: "delete" });
const secondPlan = await prepareOracleTriggerPlan({ target: second, action: "delete" });
const legacy = { id: "legacy", sql: 'DROP TRIGGER "Legacy.Owner"."Legacy";', ...(explicitUnset ? { executionSchema: undefined } : {}) };
const plan = prepareOracleTriggerDropBatchPlan({ target, engine: "oceanbase-oracle", entries: [{ id: "first", sql: firstPlan.steps[0].sql, triggerPlan: firstPlan }, legacy, { id: "second", sql: secondPlan.steps[0].sql, triggerPlan: secondPlan }] });
const result = await executeOracleTriggerDropBatchPlan(plan, { confirmed: true, isCurrent: () => true, timeoutSecs: 0 });
expect(result.steps.map((step) => step.state)).toEqual(["committed", "committed", "committed"]);
expect(result.steps[1].elapsedMs).toBeTypeOf("number");
const writes = mocks.query.mock.calls.filter((call) => !call[2].startsWith("SELECT"));
expect(writes.map((call) => call[3])).toEqual([target.executionSchema, explicitUnset ? undefined : target.executionSchema, second.executionSchema]);
expect(writes.every((call) => call[4] === undefined && call[5].catalog === target.catalog)).toBe(true);
expect(writes.map((call) => call[5].timeoutSecs)).toEqual([0, 0, 0]);
await expect(executeOracleTriggerDropBatchPlan(plan, { confirmed: true, isCurrent: () => true })).rejects.toThrow(/remaining deletions/i);
expect(mocks.query.mock.calls.filter((call) => !call[2].startsWith("SELECT"))).toHaveLength(3);
});
it.each(["tauri", "http"] as const)("sends catalog through real %s query options, not the execution identifier", async (kind) => {
const { useConnectionStore } = await import("@/stores/connectionStore");
useConnectionStore().getConfig(target.connectionId)!.query_timeout_secs = 0;
const envelopes: Record<string, unknown>[] = [];
let enabled = false;
mocks.source.mockImplementation(async () => source(enabled));
const execute = (payload: Record<string, unknown>) => {
envelopes.push(payload);
enabled = true;
return { columns: [], rows: [] };
};
mocks.invoke.mockImplementation(async (_command, payload) => execute(payload));
vi.stubGlobal(
"fetch",
vi.fn(async (_url, init) => ({ ok: true, json: async () => execute(JSON.parse(init.body)) })),
);
const transport = kind === "tauri" ? await import("@/lib/backend/tauri") : await import("@/lib/backend/http");
mocks.query.mockImplementation(transport.executeQuery);
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const result = await executeOracleTriggerPlan(await prepareOracleTriggerPlan({ target, action: "enable" }), { confirmed: true });
expect(result.steps[0]).toMatchObject({ state: "committed", verification: "applied" });
expect(envelopes).toHaveLength(1);
expect(envelopes[0]).toMatchObject({ connectionId: target.connectionId, database: target.database, schema: target.executionSchema, catalog: target.catalog, timeoutSecs: 0 });
expect(envelopes[0].executionId).toBeUndefined();
});
it("rejects a same-name replacement of the identity already shown by the calling form", async () => {
const changed = source(false);
changed.trigger!.oracle_metadata!.objectId = "replacement-id";
mocks.source.mockResolvedValue(changed);
const { prepareOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
await expect(prepareOracleTriggerPlan({ target, action: "enable", expectedObjectId: "9007199254740993" })).rejects.toThrow(/replaced|identity/i);
expect(mocks.query).not.toHaveBeenCalled();
});
it("creates the new table before obtaining its real parent ID, then sends the exact confirmed trigger", async () => {
const triggerName = "new_trigger",
parentOwner = " Parent Owner ",
tableName = "NewTable";
const tableSql = 'CREATE TABLE " Parent Owner "."NewTable" ("ID" NUMBER)';
const triggerSql = 'CREATE TRIGGER " Trigger Owner "."new_trigger" BEFORE INSERT ON " Parent Owner "."NewTable" DISABLE BEGIN NULL; END;';
let tableExists = false,
triggerExists = false;
mocks.source.mockImplementation(async () => {
const raw = source(false);
raw.name = triggerName;
raw.source = triggerExists ? triggerSql : "";
raw.trigger!.name = triggerName;
raw.trigger!.statement = "BEGIN NULL; END;";
raw.trigger!.valid = true;
Object.assign(raw.trigger!.oracle_metadata!, {
name: triggerName,
objectId: triggerExists ? "created-trigger-id" : null,
scope: triggerExists ? "TABLE" : "UNKNOWN",
parent: triggerExists ? { owner: parentOwner, name: tableName, objectType: "TABLE" } : null,
definition: { origin: "ALL_SOURCE", format: "ddl", complete: triggerExists },
});
raw.trigger!.oracle_metadata!.reads.identity = { state: triggerExists ? "available" : "empty" };
raw.trigger!.oracle_metadata!.reads.definition = { state: triggerExists ? "available" : "empty" };
return raw;
});
mocks.prepareSql.mockImplementation(async (input) => ({ definition: input.source, comparisonSource: input.source, header: { scope: "RELATION", owner: parentOwner, name: tableName, viewOnly: false, pluggable: false }, requiresStateRestore: false }));
mocks.query.mockImplementation(async (_id, _db, sql) => {
if (sql.startsWith("SELECT")) {
if (!tableExists) throw new Error("The parent does not exist before CREATE TABLE");
return { columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[parentOwner, tableName, "TABLE", "new-parent-id"]] };
}
if (sql === tableSql) tableExists = true;
if (sql === triggerSql) triggerExists = true;
return { columns: [], rows: [], affected_rows: 0 };
});
const { prepareOracleTriggerStructurePlan } = await import("@/lib/database/oracleTriggerStructurePlan");
const { executeOracleTriggerStructurePlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerStructurePlan({
target: { ...target, owner: parentOwner, tableName, parentType: "TABLE", databaseType: "oceanbase-oracle", newTable: true },
statements: [tableSql, triggerSql],
operations: [{ draftId: "new", action: "create", owner: target.owner, name: triggerName, statementIndex: 1, statementCount: 1, enabled: false }],
triggers: [{ id: "new", name: triggerName, timing: "BEFORE", event: "INSERT", statement: "BEGIN NULL; END;", enabled: false, markedForDrop: false, oracleExact: { owner: target.owner, parentType: "TABLE" } }],
});
expect(mocks.query).not.toHaveBeenCalled();
const result = await executeOracleTriggerStructurePlan(plan, { confirmed: true, isCurrent: () => true });
expect(result.steps.map((step) => step.state)).toEqual(["committed", "committed"]);
for (const call of mocks.query.mock.calls) {
expect(call[4]).toBeUndefined();
expect(call[5]).toMatchObject({ catalog: target.catalog });
}
expect(mocks.query.mock.calls.filter((call) => !call[2].startsWith("SELECT")).map((call) => call[2])).toEqual([tableSql, triggerSql]);
await expect(executeOracleTriggerStructurePlan(plan, { confirmed: true, isCurrent: () => true })).rejects.toThrow(/already attempted/i);
});
it.each([true, false])("only permits a lossless structured rename and stops after a rejected CREATE (structured=%s)", async (structured) => {
const old = source(false);
old.source = 'CREATE OR REPLACE TRIGGER " Trigger Owner "." Tr""ig " INSTEAD OF UPDATE ON " Parent Owner "." View " BEGIN NULL; END;';
if (!structured) old.source = old.source.replace(" BEGIN", " FOLLOWS OTHER_TRIGGER BEGIN");
old.trigger!.statement = "BEGIN NULL; END;";
old.trigger!.valid = true;
old.trigger!.oracle_metadata!.definition = { origin: "ALL_SOURCE", format: "ddl", complete: true };
old.trigger!.oracle_metadata!.reads.definition = { state: "available" };
let oldExists = true;
const newName = "NewTrigger",
createSql = 'CREATE TRIGGER " Trigger Owner "."NewTrigger" INSTEAD OF UPDATE ON " Parent Owner "." View " DISABLE BEGIN NULL; END;',
dropSql = 'DROP TRIGGER " Trigger Owner "." Tr""ig ";';
mocks.source.mockImplementation(async (_id, _db, _owner, name) => {
if (name === target.name && oldExists) return JSON.parse(JSON.stringify(old));
const absent = source(false);
absent.name = name;
absent.source = "";
absent.trigger!.name = name;
Object.assign(absent.trigger!.oracle_metadata!, { name, objectId: null });
absent.trigger!.oracle_metadata!.reads.identity = { state: "empty" };
return absent;
});
mocks.prepareSql.mockImplementation(async (input) => ({ definition: input.source, comparisonSource: input.source, structuredEditable: structured, header: { scope: "RELATION", owner: " Parent Owner ", name: " View ", viewOnly: true, pluggable: false }, requiresStateRestore: false }));
mocks.dropSql.mockResolvedValue(dropSql);
mocks.query.mockImplementation(async (_id, _db, sql) => {
if (sql.startsWith("SELECT USER")) return { columns: ["SESSION_USER"], rows: [[target.owner]] };
if (sql.startsWith("SELECT")) return { columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[" Parent Owner ", " View ", "VIEW", "parent-id"]] };
if (sql === dropSql) {
oldExists = false;
return { columns: [], rows: [] };
}
return {
columns: [],
rows: [],
execution_error: true,
error: {
version: 1,
code: "DBX-JDBC-4001",
messageKey: "backendErrors.jdbc.sqlFailed",
messageParams: {},
source: "jdbc-agent",
operationOutcome: "unknown",
detail: "ORA-01031: insufficient privileges",
origin: { subsystem: "database", adapter: "jdbc-agent" },
diagnostics: { category: "sql", stage: "execute", vendorCode: 1031 },
},
};
});
const { prepareOracleTriggerStructurePlan } = await import("@/lib/database/oracleTriggerStructurePlan");
const { executeOracleTriggerStructurePlan } = await import("@/lib/database/oracleTriggerPlan");
const preparing = prepareOracleTriggerStructurePlan({
target: { ...target, owner: " Parent Owner ", tableName: " View ", parentType: "VIEW", databaseType: "oceanbase-oracle", newTable: false },
statements: [dropSql, createSql, "COMMENT ON TABLE later IS 'not sent'"],
operations: [
{ draftId: "rename", action: "delete", owner: target.owner, name: target.name, statementIndex: 0, statementCount: 1 },
{ draftId: "rename", action: "create", owner: target.owner, name: newName, statementIndex: 1, statementCount: 1, enabled: false },
],
triggers: [{ id: "rename", name: newName, timing: old.trigger!.timing, event: old.trigger!.event, statement: old.trigger!.statement!, enabled: false, original: old.trigger!, markedForDrop: false, loadedOracleSource: old.source, oracleExact: { owner: target.owner, parentType: "VIEW" } }],
});
if (!structured) {
await expect(preparing).rejects.toThrow("Edit the complete trigger source");
expect(mocks.query.mock.calls.filter((call) => !call[2].startsWith("SELECT"))).toHaveLength(0);
return;
}
const plan = await preparing;
const result = await executeOracleTriggerStructurePlan(plan, { confirmed: true, isCurrent: () => true });
expect(result.steps.map((step) => step.state)).toEqual(["committed", "rejected", "notExecuted"]);
expect(plan.groups[0].plan?.before.raw.source).toBe(old.source);
expect(mocks.query.mock.calls.filter((call) => !call[2].startsWith("SELECT")).map((call) => call[2])).toEqual([dropSql, createSql]);
await expect(executeOracleTriggerStructurePlan(plan, { confirmed: true, isCurrent: () => true })).rejects.toThrow(/already attempted/i);
});
it("enables the exact trigger through its own owner without requiring a replaceable source", async () => {
mocks.source.mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(true));
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "enable" });
expect(plan.steps.map((step) => step.sql)).toEqual(['ALTER TRIGGER " Trigger Owner "." Tr""ig " ENABLE;']);
const result = await executeOracleTriggerPlan(plan, { confirmed: true });
expect(mocks.query).toHaveBeenCalledWith(target.connectionId, "service", 'ALTER TRIGGER " Trigger Owner "." Tr""ig " ENABLE;', " Execution Owner ", undefined, { catalog: "container", timeoutSecs: 60 });
expect(result.steps[0]).toMatchObject({ state: "committed", verification: "applied" });
expect(result.snapshot?.raw.trigger).toMatchObject({ enabled: true, valid: false });
expect(result.snapshot?.metadata.parent).toEqual({ owner: " Parent Owner ", name: " View ", objectType: "VIEW" });
expect(result.snapshot?.raw.source).toBe("BEGIN :NEW.V := 7; END;");
expect(result.snapshot?.metadata.errors).toEqual([{ sequence: 1, line: 3, position: 7, text: "Missing procedure" }]);
});
it("retains an unknown dispatched write and recovers by read-only verification without replaying it", async () => {
mocks.source.mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(false)).mockRejectedValueOnce(new Error("readback disconnected")).mockResolvedValueOnce(source(true)).mockResolvedValueOnce(source(true)).mockResolvedValueOnce(source(true));
mocks.query.mockRejectedValue(new Error("response lost after dispatch"));
const { prepareOracleTriggerPlan, executeOracleTriggerPlan, readOracleTriggerSnapshot } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "enable" });
const result = await executeOracleTriggerPlan(plan, { confirmed: true });
expect(result.steps[0]).toMatchObject({ state: "unknown", verification: "unverified", error: "response lost after dispatch", readbackError: "readback disconnected" });
expect(Object.isFrozen(plan.before.identity)).toBe(true);
await expect(executeOracleTriggerPlan(plan, { confirmed: true })).rejects.toThrow();
expect(mocks.query).toHaveBeenCalledTimes(1);
const verified = await readOracleTriggerSnapshot(target);
expect(verified.raw.trigger?.enabled).toBe(true);
const remaining = await prepareOracleTriggerPlan({ target, action: "enable" });
expect(remaining.steps).toEqual([]);
const recovered = await executeOracleTriggerPlan(remaining, { confirmed: true });
expect(recovered.snapshot?.raw.trigger?.enabled).toBe(true);
expect(mocks.query).toHaveBeenCalledTimes(1);
await expect(executeOracleTriggerPlan(plan, { confirmed: true })).rejects.toThrow();
});
it("keeps a verified native write committed when the auxiliary list refresh fails", async () => {
mocks.source.mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(true));
mocks.objects.mockRejectedValueOnce(new Error("list refresh failed"));
const api = await import("@/lib/backend/api");
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "enable" });
const result = await executeOracleTriggerPlan(plan, {
confirmed: true,
refresh: async (fixed) => {
await api.listObjects(fixed.connectionId, fixed.database, fixed.owner, ["TRIGGER"]);
},
});
expect(result.steps[0]).toMatchObject({ state: "committed", verification: "applied" });
expect(result.refreshError).toBe("list refresh failed");
expect(mocks.objects).toHaveBeenCalledWith(target.connectionId, "service", " Trigger Owner ", ["TRIGGER"]);
expect(mocks.query).toHaveBeenCalledTimes(1);
});
it.each([
{
name: "native permission refusal",
state: "rejected",
receipt: "rejected",
error: {
version: 1,
code: "DBX-JDBC-4001",
messageKey: "backendErrors.jdbc.sqlFailed",
messageParams: { stage: "execute" },
source: "jdbc-agent",
operationOutcome: "unknown",
origin: { subsystem: "database", adapter: "jdbc-agent" },
detail: "ORA-01031: insufficient privileges",
diagnostics: { category: "sql", stage: "execute", sqlState: "42000", vendorCode: 1031 },
} as BackendError,
},
{
name: "known pre-execution failure",
state: "notExecuted",
receipt: "notStarted",
error: {
version: 1,
code: "DBX-JDBC-1001",
messageKey: "backendErrors.jdbc.connectionFailed",
messageParams: { stage: "connect" },
source: "jdbc-agent",
operationOutcome: "not_started",
origin: { subsystem: "database", adapter: "jdbc-agent" },
detail: "Connection could not start",
diagnostics: { category: "connection", stage: "connect" },
} as BackendError,
},
])("separates $name from an unknown write", async ({ error, state, receipt }) => {
mocks.source.mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(false));
mocks.query.mockResolvedValueOnce({ columns: [], rows: [], affected_rows: 0, execution_time_ms: 1, execution_error: true, error });
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "enable" });
const result = await executeOracleTriggerPlan(plan, { confirmed: true });
expect(result.steps[0]).toMatchObject({ state, verification: "unchanged", receipt, error: error.detail });
expect(result.snapshot?.raw.trigger?.enabled).toBe(false);
expect(mocks.query).toHaveBeenCalledTimes(1);
await expect(executeOracleTriggerPlan(plan, { confirmed: true })).rejects.toThrow();
});
it.each([true, false])("does not request write access for an unchanged action, but preserves the guard when currently enabled=%s", async (enabled) => {
const { useConnectionStore } = await import("@/stores/connectionStore");
useConnectionStore().getConfig(target.connectionId)!.read_only = true;
mocks.source.mockResolvedValue(source(enabled));
const { useReadOnlyUnlockStore } = await import("@/stores/readOnlyUnlockStore");
const unlock = useReadOnlyUnlockStore();
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "enable" });
let finished = false;
const pending = executeOracleTriggerPlan(plan, { confirmed: true }).then((result) => {
finished = true;
return result;
});
await vi.waitFor(() => expect(finished || Boolean(unlock.pending)).toBe(true));
const requested = unlock.pending;
if (requested) unlock.cancel();
const result = await pending;
expect(Boolean(requested)).toBe(!enabled);
if (enabled) {
expect(result.cancelled).not.toBe(true);
expect(result.snapshot?.raw.trigger?.enabled).toBe(true);
expect(mocks.unlockState).not.toHaveBeenCalled();
} else expect(result.cancelled).toBe(true);
expect(mocks.query).not.toHaveBeenCalled();
});
it("compiles a verified OB trigger without a parent/full source and reports HTTP-success-but-INVALID", async () => {
const raw = source(true);
raw.trigger!.oracle_metadata!.scope = "UNKNOWN";
raw.trigger!.oracle_metadata!.parent = null;
raw.trigger!.oracle_metadata!.reads.scope = { state: "unavailable" };
raw.trigger!.oracle_metadata!.reads.parent = { state: "unavailable" };
mocks.source.mockResolvedValue(raw);
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "compile" });
expect(plan.steps.map((step) => step.sql)).toEqual(['ALTER TRIGGER " Trigger Owner "." Tr""ig " COMPILE']);
const result = await executeOracleTriggerPlan(plan, { confirmed: true });
expect(result.steps[0]).toMatchObject({ state: "committed", verification: "invalid", receipt: "accepted" });
expect(result.snapshot?.raw.trigger).toMatchObject({ enabled: true, valid: false });
expect(result.snapshot?.metadata.errors).toEqual([{ sequence: 1, line: 3, position: 7, text: "Missing procedure" }]);
expect(mocks.query.mock.calls.map((call) => call[2])).toEqual(['ALTER TRIGGER " Trigger Owner "." Tr""ig " COMPILE']);
});
it("rejects a same-ID same-second source change inside a q-quoted literal before sending DDL", async () => {
const before = source(false),
changed = source(false),
after = source(true);
before.source = "BEGIN :NEW.V := q'[first\r\nsecond]'; END;";
changed.source = "BEGIN :NEW.V := q'[first\nsecond]'; END;";
after.source = changed.source;
mocks.source.mockResolvedValueOnce(before).mockResolvedValueOnce(changed).mockResolvedValueOnce(after);
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "enable" });
await expect(executeOracleTriggerPlan(plan, { confirmed: true })).rejects.toThrow("changed");
expect(mocks.query).not.toHaveBeenCalled();
});
it("keeps the requested action and execution target fixed while metadata is loading", async () => {
let release!: (value: ObjectSource) => void;
mocks.source.mockReturnValueOnce(
new Promise<ObjectSource>((resolve) => {
release = resolve;
}),
);
const { prepareOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const input = { target: { ...target }, action: "enable" as "enable" | "disable" };
const pending = prepareOracleTriggerPlan(input);
input.action = "disable";
input.target.owner = "Changed Owner";
input.target.executionSchema = "Changed Execution";
release(source(false));
const plan = await pending;
expect(plan.action).toBe("enable");
expect(plan.target).toEqual(target);
expect(plan.steps.map((step) => step.sql)).toEqual(['ALTER TRIGGER " Trigger Owner "." Tr""ig " ENABLE;']);
expect(mocks.query).not.toHaveBeenCalled();
});
it("reads DM's disabled INVALID state after a native compilation error and never sends ENABLE", async () => {
const { useConnectionStore } = await import("@/stores/connectionStore");
useConnectionStore().getConfig(target.connectionId)!.db_type = "jdbc";
const before = source(true),
after = source(false);
before.trigger!.valid = true;
before.trigger!.oracle_metadata!.errors = [];
for (const raw of [before, after]) {
raw.trigger!.oracle_metadata!.engine = "dm";
raw.trigger!.oracle_metadata!.engineVersion = "8.1.5";
}
after.trigger!.oracle_metadata!.lastDdlTime = "2026-10-21 08:00:01";
mocks.source.mockResolvedValueOnce(before).mockResolvedValueOnce(before).mockResolvedValueOnce(after);
const error: BackendError = {
version: 1,
code: "DBX-JDBC-4001",
messageKey: "backendErrors.jdbc.sqlFailed",
messageParams: { stage: "execute" },
source: "jdbc-agent",
operationOutcome: "unknown",
origin: { subsystem: "database", adapter: "jdbc-agent" },
detail: "Trigger compilation failed",
diagnostics: { category: "sql", stage: "execute", sqlState: "42000", vendorCode: -2007 },
};
mocks.query.mockResolvedValueOnce({ columns: [], rows: [], affected_rows: 0, execution_time_ms: 1, execution_error: true, error });
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "compile" });
const result = await executeOracleTriggerPlan(plan, { confirmed: true });
expect(result.steps[0]).toMatchObject({ verification: "invalid", error: "Trigger compilation failed" });
expect(result.snapshot?.raw.trigger).toMatchObject({ enabled: false, valid: false });
expect(result.snapshot?.metadata.errors?.[0]).toMatchObject({ line: 3, position: 7, text: "Missing procedure" });
expect(mocks.query.mock.calls.map((call) => call[2])).toEqual(['ALTER TRIGGER " Trigger Owner "." Tr""ig " COMPILE']);
});
it("creates only a plain CREATE on the verified independent parent and reports the actual INVALID object", async () => {
const absent = source(false),
created = source(false);
absent.source = "";
absent.trigger!.oracle_metadata!.objectId = null;
absent.trigger!.oracle_metadata!.reads.identity = { state: "empty" };
const definition = 'CREATE TRIGGER " Trigger Owner "." Tr""ig " INSTEAD OF UPDATE ON " Parent Owner "." View " DISABLE BEGIN NULL; END;';
created.source = definition;
created.trigger!.oracle_metadata!.definition = { origin: "DBMS_METADATA", format: "ddl", complete: true };
created.trigger!.oracle_metadata!.reads.definition = { state: "available" };
mocks.prepareSql.mockResolvedValue({ definition, comparisonSource: definition, header: { scope: "RELATION", owner: " Parent Owner ", name: " View ", viewOnly: true, pluggable: false }, inlineEnabled: false, requiresStateRestore: false });
mocks.source.mockResolvedValueOnce(absent).mockResolvedValueOnce(absent).mockResolvedValueOnce(created);
mocks.query.mockImplementation(async (_id, _db, sql) => (sql.startsWith("SELECT") ? { columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[" Parent Owner ", " View ", "VIEW", "9007199254740995"]] } : { columns: [], rows: [] }));
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "create", source: definition, enabled: false, selection: { scope: "VIEW", owner: " Parent Owner ", name: " View " } });
expect(plan.expectedAfter?.binding).toEqual({ scope: "VIEW", owner: " Parent Owner ", name: " View ", pluggable: false });
expect(plan.steps.map((step) => step.sql)).toEqual([definition]);
const result = await executeOracleTriggerPlan(plan, { confirmed: true });
expect(result.steps[0]).toMatchObject({ state: "committed", verification: "invalid" });
expect(mocks.query.mock.calls.filter((call) => !call[2].startsWith("SELECT")).map((call) => call[2])).toEqual([definition]);
});
it("blocks replacement against a different loaded source baseline and a parent rebuilt after confirmation", async () => {
const before = source(false);
before.source = 'CREATE TRIGGER " Trigger Owner "." Tr""ig " INSTEAD OF UPDATE ON " Parent Owner "." View " DISABLE BEGIN NULL; END;';
before.trigger!.oracle_metadata!.definition = { origin: "DBMS_METADATA", format: "ddl", complete: true };
before.trigger!.oracle_metadata!.reads.definition = { state: "available" };
mocks.prepareSql.mockResolvedValue({ definition: before.source, comparisonSource: before.source, header: { scope: "RELATION", owner: " Parent Owner ", name: " View ", viewOnly: true, pluggable: false }, requiresStateRestore: false });
mocks.source.mockResolvedValue(before);
let parentReads = 0;
mocks.query.mockImplementation(async () => ({ columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[" Parent Owner ", " View ", "VIEW", ++parentReads === 1 ? "parent-before" : "parent-rebuilt"]] }));
const { readOracleTriggerSnapshot, prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const baseline = await readOracleTriggerSnapshot(target);
const plan = await prepareOracleTriggerPlan({ target, action: "replace", baseline, source: before.source });
await expect(executeOracleTriggerPlan(plan, { confirmed: true })).rejects.toThrow(/owning object|parent|scope/i);
expect(mocks.query.mock.calls.every((call) => call[2].startsWith("SELECT"))).toBe(true);
const changed = JSON.parse(JSON.stringify(before));
changed.source += " -- other writer";
mocks.source.mockResolvedValue(changed);
await expect(prepareOracleTriggerPlan({ target, action: "replace", baseline, source: before.source })).rejects.toThrow(/changed|baseline/i);
});
it("does not treat a cross-owner empty ALL_* read as a verified deletion when the global dictionary is denied", async () => {
const absent = source(false);
absent.source = "";
absent.trigger!.oracle_metadata!.objectId = null;
absent.trigger!.oracle_metadata!.reads.identity = { state: "empty" };
mocks.source.mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(false)).mockResolvedValueOnce(absent);
mocks.query.mockImplementation(async (_id, _db, sql) => {
if (sql.includes("DBA_OBJECTS")) throw new Error("global dictionary denied");
if (sql.includes("SELECT USER")) return { columns: ["SESSION_USER"], rows: [[" Execution Owner "]] };
if (sql.startsWith("SELECT")) return { columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[" Parent Owner ", " View ", "VIEW", "parent-before"]] };
return { columns: [], rows: [] };
});
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "delete" });
const result = await executeOracleTriggerPlan(plan, { confirmed: true });
expect(result.steps[0]).toMatchObject({ state: "unknown", verification: "unverified", receipt: "accepted" });
expect(result.steps[0].readbackError).toContain("global dictionary denied");
expect(mocks.query.mock.calls.filter((call) => !call[2].startsWith("SELECT")).map((call) => call[2])).toEqual(['DROP TRIGGER " Trigger Owner "." Tr""ig ";']);
await expect(executeOracleTriggerPlan(plan, { confirmed: true })).rejects.toThrow();
});
it("keeps DM's committed definition and stops its separately previewed disabled-state restoration after a lost receipt", async () => {
const absent = source(false),
created = source(true);
const definition = 'CREATE TRIGGER " Trigger Owner "." Tr""ig " INSTEAD OF UPDATE ON " Parent Owner "." View " BEGIN NULL; END;';
for (const raw of [absent, created]) {
raw.trigger!.oracle_metadata!.engine = "dm";
raw.trigger!.oracle_metadata!.engineVersion = "8.1.5";
}
absent.source = "";
absent.trigger!.oracle_metadata!.objectId = null;
absent.trigger!.oracle_metadata!.reads.identity = { state: "empty" };
created.source = definition;
created.trigger!.valid = true;
created.trigger!.oracle_metadata!.definition = { origin: "DBMS_METADATA", format: "ddl", complete: true };
created.trigger!.oracle_metadata!.reads.definition = { state: "available" };
mocks.source.mockResolvedValueOnce(absent).mockResolvedValueOnce(absent).mockResolvedValueOnce(created);
mocks.prepareSql.mockResolvedValue({ definition, comparisonSource: definition, header: { scope: "RELATION", owner: " Parent Owner ", name: " View ", viewOnly: true, pluggable: false }, requiresStateRestore: true });
mocks.query.mockImplementation(async (_id, _db, sql) => {
if (sql.startsWith("SELECT")) return { columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[" Parent Owner ", " View ", "VIEW", "parent-before"]] };
throw new Error("write response lost");
});
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const plan = await prepareOracleTriggerPlan({ target, action: "create", source: definition, enabled: false, selection: { scope: "VIEW", owner: " Parent Owner ", name: " View " } });
expect(plan.steps.map((step) => step.action)).toEqual(["create", "disable"]);
const result = await executeOracleTriggerPlan(plan, { confirmed: true });
expect(result.steps.map(({ state, verification }) => ({ state, verification }))).toEqual([
{ state: "unknown", verification: "applied" },
{ state: "notExecuted", verification: "unverified" },
]);
expect(result.snapshot?.raw.trigger?.enabled).toBe(true);
expect(mocks.query.mock.calls.filter((call) => !call[2].startsWith("SELECT")).map((call) => call[2])).toEqual([definition]);
await expect(executeOracleTriggerPlan(plan, { confirmed: true })).rejects.toThrow();
});
it("verifies a deletion of the actual session user's trigger without requiring DBA_OBJECTS and leaves the parent intact", async () => {
const absent = source(false);
absent.source = "";
absent.trigger!.oracle_metadata!.objectId = null;
absent.trigger!.oracle_metadata!.reads.identity = { state: "empty" };
mocks.source.mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(false)).mockResolvedValueOnce(absent);
mocks.query.mockImplementation(async (_id, _db, sql) => {
if (sql.includes("SELECT USER")) return { columns: ["SESSION_USER"], rows: [[target.owner]] };
if (sql.startsWith("SELECT")) return { columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[" Parent Owner ", " View ", "VIEW", "parent-before"]] };
return { columns: [], rows: [] };
});
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const result = await executeOracleTriggerPlan(await prepareOracleTriggerPlan({ target, action: "delete" }), { confirmed: true });
expect(result.steps[0]).toMatchObject({ state: "committed", verification: "deleted" });
expect(mocks.query.mock.calls.some((call) => call[2].includes("DBA_OBJECTS"))).toBe(false);
expect(mocks.query.mock.calls.filter((call) => !call[2].startsWith("SELECT")).map((call) => call[2])).toEqual(['DROP TRIGGER " Trigger Owner "." Tr""ig ";']);
});
it("keeps a post-dispatch result on its fixed target when only the UI moves away", async () => {
let current = true;
mocks.source.mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(true));
mocks.query.mockImplementationOnce(async () => {
current = false;
return { columns: [], rows: [] };
});
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const result = await executeOracleTriggerPlan(await prepareOracleTriggerPlan({ target, action: "enable" }), { confirmed: true, isCurrent: () => current });
expect(result.steps[0]).toMatchObject({ state: "committed", verification: "applied" });
expect(result.snapshot?.target).toEqual(target);
expect(mocks.query).toHaveBeenCalledTimes(1);
});
it("retires only the real parent's trigger facets after a write, keeping columns and another catalog warm", async () => {
const { loadObjectMetadataFacet } = await import("@/lib/metadata/objectMetadataCache");
const parent = { connectionId: target.connectionId, database: target.database, catalog: target.catalog, schema: " Parent Owner ", tableName: " View ", objectType: "VIEW" as const };
await loadObjectMetadataFacet(parent, "columns", async () => ["column-keep"]);
await loadObjectMetadataFacet(parent, "triggers", async () => ["legacy-old"]);
await loadObjectMetadataFacet({ ...parent, oracleTriggerContract: 1 }, "triggers", async () => ["exact-old"]);
await loadObjectMetadataFacet({ ...parent, exactIdentity: true, oracleTriggerContract: 1 }, "triggers", async () => ["identity-old"]);
await loadObjectMetadataFacet({ ...parent, catalog: "another-catalog" }, "triggers", async () => ["catalog-keep"]);
mocks.source.mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(false)).mockResolvedValueOnce(source(true));
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
await executeOracleTriggerPlan(await prepareOracleTriggerPlan({ target, action: "enable" }), { confirmed: true });
expect((await loadObjectMetadataFacet(parent, "triggers", async () => ["legacy-new"])).value).toEqual(["legacy-new"]);
expect((await loadObjectMetadataFacet({ ...parent, oracleTriggerContract: 1 }, "triggers", async () => ["exact-new"])).value).toEqual(["exact-new"]);
expect((await loadObjectMetadataFacet({ ...parent, exactIdentity: true, oracleTriggerContract: 1 }, "triggers", async () => ["identity-new"])).value).toEqual(["identity-new"]);
expect((await loadObjectMetadataFacet(parent, "columns", async () => ["incorrect-column-reload"])).value).toEqual(["column-keep"]);
expect((await loadObjectMetadataFacet({ ...parent, catalog: "another-catalog" }, "triggers", async () => ["incorrect-catalog-reload"])).value).toEqual(["catalog-keep"]);
});
it("does not report an enable as verified when a known complete body changed during execution", async () => {
const before = source(false),
after = source(true);
for (const raw of [before, after]) {
raw.trigger!.oracle_metadata!.definition = { origin: "DBMS_METADATA", format: "ddl", complete: true };
raw.trigger!.oracle_metadata!.reads.definition = { state: "available" };
}
before.source = 'CREATE TRIGGER " Trigger Owner "." Tr""ig " INSTEAD OF UPDATE ON " Parent Owner "." View " BEGIN NULL; END;';
after.source = before.source.replace("NULL;", "other_procedure;");
mocks.source.mockResolvedValueOnce(before).mockResolvedValueOnce(before).mockResolvedValueOnce(after);
mocks.prepareSql.mockImplementation(async (input) => ({ definition: input.source, comparisonSource: input.source, header: { scope: "RELATION", owner: " Parent Owner ", name: " View ", viewOnly: true, pluggable: false }, requiresStateRestore: false }));
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const result = await executeOracleTriggerPlan(await prepareOracleTriggerPlan({ target, action: "enable" }), { confirmed: true });
expect(result.steps[0]).toMatchObject({ state: "unknown", verification: "mismatch", receipt: "accepted" });
expect(result.snapshot?.raw.trigger?.enabled).toBe(true);
expect(mocks.query).toHaveBeenCalledTimes(1);
});
it.each(["enable", "replace"] as const)("rechecks action-specific read authority after confirmation for %s", async (action) => {
const before = source(false);
before.source = 'CREATE TRIGGER " Trigger Owner "." Tr""ig " INSTEAD OF UPDATE ON " Parent Owner "." View " DISABLE BEGIN NULL; END;';
before.trigger!.oracle_metadata!.definition = { origin: "DBMS_METADATA", format: "ddl", complete: true };
before.trigger!.oracle_metadata!.reads.definition = { state: "available" };
const latest: ObjectSource = JSON.parse(JSON.stringify(before));
if (action === "replace") {
latest.trigger!.oracle_metadata!.definition!.complete = false;
latest.trigger!.oracle_metadata!.reads.definition = { state: "denied" };
} else latest.trigger!.oracle_metadata!.reads.scope = { state: "unavailable" };
mocks.prepareSql.mockImplementation(async (input) => ({ definition: input.source, comparisonSource: input.source, header: { scope: "RELATION", owner: " Parent Owner ", name: " View ", viewOnly: true, pluggable: false }, requiresStateRestore: false }));
mocks.query.mockImplementation(async () => ({ columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[" Parent Owner ", " View ", "VIEW", "parent-id"]] }));
mocks.source.mockResolvedValueOnce(before);
const { prepareOracleTriggerPlan, readOracleTriggerSnapshot, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const baseline = action === "replace" ? await readOracleTriggerSnapshot(target) : undefined;
if (baseline) mocks.source.mockResolvedValueOnce(before);
const plan = await prepareOracleTriggerPlan({ target, action, ...(baseline ? { baseline, source: before.source } : {}) });
mocks.source.mockResolvedValue(latest);
await expect(executeOracleTriggerPlan(plan, { confirmed: true })).rejects.toThrow(/complete|scope|unavailable/i);
expect(mocks.query.mock.calls.every((call) => call[2].startsWith("SELECT"))).toBe(true);
});
it("verifies a plain CREATE against OceanBase's CREATE OR REPLACE export wrapper without changing its body", async () => {
const absent = source(false),
created = source(true);
absent.source = "";
absent.trigger!.oracle_metadata!.objectId = null;
absent.trigger!.oracle_metadata!.reads.identity = { state: "empty" };
const tail = ' " Trigger Owner "." Tr""ig " INSTEAD OF UPDATE ON " Parent Owner "." View " ENABLE\nBEGIN NULL; END;';
const definition = `CREATE TRIGGER${tail}`,
exported = `CREATE OR REPLACE TRIGGER${tail}`;
created.source = `${exported}\nALTER TRIGGER " Trigger Owner "." Tr""ig " ENABLE`;
created.trigger!.valid = true;
created.trigger!.oracle_metadata!.definition = { origin: "DBMS_METADATA", format: "ddl", complete: true };
created.trigger!.oracle_metadata!.reads.definition = { state: "available" };
mocks.prepareSql.mockImplementation(async (input) => ({
definition: input.source === created.source ? exported : input.source === exported && input.purpose === "create" ? `CREATE TRIGGER${tail}` : definition,
comparisonSource: exported,
header: { scope: "RELATION", owner: " Parent Owner ", name: " View ", viewOnly: true, pluggable: false },
requiresStateRestore: false,
}));
mocks.source.mockResolvedValueOnce(absent).mockResolvedValueOnce(absent).mockResolvedValueOnce(created);
mocks.query.mockImplementation(async (_id, _db, sql) => (sql.startsWith("SELECT") ? { columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[" Parent Owner ", " View ", "VIEW", "parent-id"]] } : { columns: [], rows: [] }));
const { prepareOracleTriggerPlan, executeOracleTriggerPlan } = await import("@/lib/database/oracleTriggerPlan");
const result = await executeOracleTriggerPlan(await prepareOracleTriggerPlan({ target, action: "create", source: definition, selection: { scope: "VIEW", owner: " Parent Owner ", name: " View " } }), { confirmed: true });
expect(result.steps[0]).toMatchObject({ state: "committed", verification: "applied" });
expect(mocks.query.mock.calls.filter((call) => !call[2].startsWith("SELECT")).map((call) => call[2])).toEqual([definition]);
});
});