feat(mysql): support changing user account host

Closes #4677
This commit is contained in:
t8y2 committed 2026-08-14 00:41:17 +00:00
1 parent 2ecbac4a6f
commit c892c8d1b0
13 files changed
+279 -6

No files matched your search

@@ -7,6 +7,9 @@ import type { ConnectionConfig } from "@/types/database";
const mocks = vi.hoisted(() => ({
ensureConnected: vi.fn(),
executeQuery: vi.fn(),
executeMulti: vi.fn(),
productionGuard: vi.fn(),
toast: vi.fn(),
}));
function passthrough(tag: string): Component {
@@ -18,12 +21,40 @@ function passthrough(tag: string): Component {
});
}
vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key }) }));
function modelInput(): Component {
return defineComponent({
inheritAttrs: false,
setup(_, { attrs }) {
return () =>
h("input", {
...attrs,
value: attrs.modelValue as string,
onInput: (event: Event) => (attrs["onUpdate:modelValue"] as ((value: string) => void) | undefined)?.((event.target as HTMLInputElement).value),
});
},
});
}
function modelDialog(): Component {
return defineComponent({
inheritAttrs: false,
setup(_, { attrs, slots }) {
return () => (attrs.open ? h("div", attrs, slots.default?.()) : null);
},
});
}
vi.mock("vue-i18n", () => ({
useI18n: () => ({
t: (key: string, values?: Record<string, unknown>) => (values?.message ? `${key}: ${values.message}` : key),
}),
}));
vi.mock("@lucide/vue", () => {
const Icon = passthrough("span");
return {
AlertTriangle: Icon,
Check: Icon,
Globe2: Icon,
KeyRound: Icon,
Lock: Icon,
Loader2: Icon,
@@ -39,13 +70,13 @@ vi.mock("@lucide/vue", () => {
vi.mock("@/components/ui/button", () => ({ Button: passthrough("button") }));
vi.mock("@/components/ui/badge", () => ({ Badge: passthrough("span") }));
vi.mock("@/components/ui/dialog", () => ({
Dialog: passthrough("div"),
Dialog: modelDialog(),
DialogContent: passthrough("div"),
DialogFooter: passthrough("div"),
DialogHeader: passthrough("div"),
DialogTitle: passthrough("div"),
}));
vi.mock("@/components/ui/input", () => ({ Input: passthrough("input") }));
vi.mock("@/components/ui/input", () => ({ Input: modelInput() }));
vi.mock("@/components/ui/PasswordInput.vue", () => ({ default: passthrough("input") }));
vi.mock("@/components/ui/select", () => ({
Select: passthrough("div"),
@@ -57,14 +88,20 @@ vi.mock("@/components/ui/select", () => ({
vi.mock("@/stores/connectionStore", () => ({
useConnectionStore: () => ({ ensureConnected: mocks.ensureConnected }),
}));
vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: vi.fn() }) }));
vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));
vi.mock("@/composables/useSqlHighlighter", () => ({ useSqlHighlighter: () => ({ highlight: (sql: string) => sql }) }));
vi.mock("@/lib/backend/api", () => ({
executeQuery: mocks.executeQuery,
executeMulti: vi.fn(),
executeMulti: mocks.executeMulti,
listDatabases: vi.fn(),
listSchemas: vi.fn(),
}));
vi.mock("@/lib/database/productionExecutionGuard", () => ({
executeWithProductionSqlGuard: (options: { execute: () => Promise<unknown> }) => {
mocks.productionGuard(options);
return options.execute();
},
}));
import DatabaseUserAdmin from "@/components/admin/DatabaseUserAdmin.vue";
@@ -79,6 +116,15 @@ const connection: ConnectionConfig = {
password: "",
};
const nativeMysqlConnection: ConnectionConfig = {
...connection,
id: "native-mysql",
name: "Native MySQL",
db_type: "mysql",
driver_profile: "mysql",
port: 3306,
};
let app: ReturnType<typeof createApp> | undefined;
let root: HTMLDivElement | undefined;
@@ -142,3 +188,101 @@ describe("DatabaseUserAdmin MySQL grant loading", () => {
expect(root.textContent).not.toContain("Access denied");
});
});
function findButton(text: string): HTMLButtonElement | undefined {
return Array.from(root?.querySelectorAll("button") ?? []).find((button) => button.textContent?.trim() === text);
}
async function mountNativeMysqlUserAdmin() {
mocks.ensureConnected.mockResolvedValue(undefined);
mocks.executeQuery.mockResolvedValueOnce({ columns: ["user", "host", "plugin"], rows: [["same-user", "old-host", "caching_sha2_password"]] }).mockResolvedValueOnce({ columns: ["Grants"], rows: [["GRANT SELECT ON *.* TO 'same-user'@'old-host'"]] });
root = document.createElement("div");
document.body.append(root);
app = createApp(DatabaseUserAdmin, { connection: nativeMysqlConnection });
app.mount(root);
await vi.waitFor(() => expect(mocks.executeQuery).toHaveBeenCalledTimes(2));
await nextTick();
}
describe("DatabaseUserAdmin MySQL account Host changes", () => {
it("shows the action only for native MySQL and validates the replacement Host", async () => {
await mountNativeMysqlUserAdmin();
findButton("userAdmin.changeHost")?.click();
await nextTick();
const hostInput = root?.querySelector<HTMLInputElement>('input[placeholder="userAdmin.newHost"]');
const previewButton = findButton("userAdmin.previewSql");
expect(hostInput?.value).toBe("old-host");
expect(previewButton?.disabled).toBe(true);
hostInput!.value = " ";
hostInput!.dispatchEvent(new Event("input", { bubbles: true }));
await nextTick();
expect(previewButton?.disabled).toBe(true);
hostInput!.value = " old-host ";
hostInput!.dispatchEvent(new Event("input", { bubbles: true }));
await nextTick();
expect(previewButton?.disabled).toBe(true);
const nonNativeRoot = document.createElement("div");
document.body.append(nonNativeRoot);
app?.unmount();
mocks.executeQuery.mockReset();
mocks.executeQuery.mockResolvedValueOnce({ columns: ["user", "host", "plugin"], rows: [["same-user", "old-host", "mysql_native_password"]] }).mockResolvedValueOnce({ columns: ["Grants"], rows: [[]] });
app = createApp(DatabaseUserAdmin, { connection });
app.mount(nonNativeRoot);
root?.remove();
root = nonNativeRoot;
await vi.waitFor(() => expect(mocks.executeQuery).toHaveBeenCalledTimes(2));
expect(findButton("userAdmin.changeHost")).toBeUndefined();
});
it("previews the exact RENAME USER SQL and reloads the renamed identity after success", async () => {
await mountNativeMysqlUserAdmin();
findButton("userAdmin.changeHost")?.click();
await nextTick();
const hostInput = root?.querySelector<HTMLInputElement>('input[placeholder="userAdmin.newHost"]');
hostInput!.value = "new-host";
hostInput!.dispatchEvent(new Event("input", { bubbles: true }));
await nextTick();
findButton("userAdmin.previewSql")?.click();
await nextTick();
expect(root?.textContent).toContain("RENAME USER 'same-user'@'old-host' TO 'same-user'@'new-host';");
expect(findButton("userAdmin.applySql")?.getAttribute("variant")).toBe("destructive");
mocks.executeMulti.mockResolvedValueOnce([]);
mocks.executeQuery.mockResolvedValueOnce({ columns: ["user", "host", "plugin"], rows: [["same-user", "new-host", "caching_sha2_password"]] }).mockResolvedValueOnce({ columns: ["Grants"], rows: [["GRANT SELECT ON *.* TO 'same-user'@'new-host'"]] });
findButton("userAdmin.applySql")?.click();
await vi.waitFor(() => expect(mocks.executeMulti).toHaveBeenCalledTimes(1));
await vi.waitFor(() => expect(mocks.executeQuery.mock.calls.some((call) => call[2] === "SHOW GRANTS FOR 'same-user'@'new-host';")).toBe(true));
expect(mocks.executeMulti.mock.calls[0][2]).toBe("RENAME USER 'same-user'@'old-host' TO 'same-user'@'new-host';");
expect(mocks.productionGuard).toHaveBeenCalledWith(expect.objectContaining({ connection: nativeMysqlConnection, sql: "RENAME USER 'same-user'@'old-host' TO 'same-user'@'new-host';" }));
expect(mocks.executeQuery.mock.calls.slice(2).map((call) => call[2])).toEqual([
"SELECT User AS user, Host AS host, plugin AS plugin FROM mysql.user ORDER BY User, Host;",
"SHOW GRANTS FOR 'same-user'@'new-host';",
]);
expect(root?.textContent).toContain("same-user@new-host");
expect(root?.querySelector('input[placeholder="userAdmin.newHost"]')).toBeNull();
});
it("keeps the old identity selected and surfaces execution errors", async () => {
await mountNativeMysqlUserAdmin();
findButton("userAdmin.changeHost")?.click();
await nextTick();
const hostInput = root?.querySelector<HTMLInputElement>('input[placeholder="userAdmin.newHost"]');
hostInput!.value = "existing-host";
hostInput!.dispatchEvent(new Event("input", { bubbles: true }));
await nextTick();
findButton("userAdmin.previewSql")?.click();
await nextTick();
mocks.executeMulti.mockResolvedValueOnce([{ columns: ["error"], rows: [["Operation RENAME USER failed"]], execution_error: true }]);
findButton("userAdmin.applySql")?.click();
await vi.waitFor(() => expect(mocks.toast).toHaveBeenCalledWith("userAdmin.applyFailed: Operation RENAME USER failed", 5000));
expect(root?.textContent).toContain("same-user@old-host");
expect(root?.querySelector<HTMLInputElement>('input[placeholder="userAdmin.newHost"]')?.value).toBe("existing-host");
expect(mocks.executeQuery).toHaveBeenCalledTimes(2);
});
});
@@ -9,6 +9,7 @@ import {
kingbaseShowGrantsSql,
kingbaseUserAdminProvider,
mysqlPrivilegeSelectionFromGrants,
nativeMysqlUserAdminProvider,
postgresUserAdminProvider,
resolveDatabaseUserAdminProviderForConnection,
} from "@/lib/database/databaseUserAdmin";
@@ -80,6 +81,35 @@ describe("MySQL grant privilege selection", () => {
});
describe("database user admin providers", () => {
it("opts only native MySQL connections into account Host changes", () => {
const legacyNative = resolveDatabaseUserAdminProviderForConnection(connection("mysql"));
const blankLegacyNative = resolveDatabaseUserAdminProviderForConnection(connection("mysql", " "));
const native = resolveDatabaseUserAdminProviderForConnection(connection("mysql", "mysql"));
const normalizedNative = resolveDatabaseUserAdminProviderForConnection(connection("mysql", " MySQL "));
expect(legacyNative).toBe(nativeMysqlUserAdminProvider);
expect(blankLegacyNative).toBe(nativeMysqlUserAdminProvider);
expect(native).toBe(nativeMysqlUserAdminProvider);
expect(normalizedNative).toBe(nativeMysqlUserAdminProvider);
expect(native?.renameUserSql?.({ user: "app'user", host: "old\\host" }, "new'\\host")).toBe(
"RENAME USER 'app''user'@'old\\\\host' TO 'app''user'@'new''\\\\host';",
);
});
it("does not expose account Host changes to MySQL-compatible providers", () => {
const jdbcMysql = { ...connection("jdbc", "mysql"), connection_string: "jdbc:mysql://localhost:3306/app" };
expect(getDatabaseUserAdminProvider("mysql")?.renameUserSql).toBeUndefined();
expect(resolveDatabaseUserAdminProviderForConnection(connection("goldendb", "goldendb"))?.renameUserSql).toBeUndefined();
expect(resolveDatabaseUserAdminProviderForConnection(jdbcMysql)?.renameUserSql).toBeUndefined();
for (const profile of ["mariadb", "oceanbase", "tidb", "tdsql", "polardb", "greatsql", "goldendb", "doris", "selectdb", "starrocks"]) {
expect(resolveDatabaseUserAdminProviderForConnection(connection("mysql", profile))?.renameUserSql, profile).toBeUndefined();
}
for (const dbType of ["gbase", "doris", "starrocks", "postgres"] as const) {
expect(resolveDatabaseUserAdminProviderForConnection(connection(dbType, dbType))?.renameUserSql, dbType).toBeUndefined();
}
});
it("selects the dedicated provider for GaussDB M-mode connections", () => {
const provider = resolveDatabaseUserAdminProviderForConnection(connection("gaussdb", "GAUSSDB-M"));
@@ -48,6 +48,7 @@ export interface DatabaseUserAdminProvider {
showGrantsSql(user: DatabaseUserIdentity): string;
parseGrants?(result: QueryResult): string[];
createUserSql?(input: CreatePrincipalInput): string;
renameUserSql?(user: DatabaseUserIdentity, newHost: string): string;
alterPasswordSql?(user: DatabaseUserIdentity, password: string): string;
alterLoginSql?(user: DatabaseUserIdentity, enabled: boolean): string;
dropUserSql?(user: DatabaseUserIdentity): string;
@@ -163,6 +164,10 @@ export function mysqlCreateUserSql(input: CreatePrincipalInput): string {
return `CREATE USER ${mysqlUserAccount(input)} IDENTIFIED BY ${quoteMySqlString(input.password)};`;
}
export function mysqlRenameUserHostSql(user: DatabaseUserIdentity, newHost: string): string {
return `RENAME USER ${mysqlUserAccount(user)} TO ${mysqlUserAccount({ ...user, host: newHost })};`;
}
export function mysqlAlterUserPasswordSql(user: DatabaseUserIdentity, password: string): string {
return `ALTER USER ${mysqlUserAccount(user)} IDENTIFIED BY ${quoteMySqlString(password)};`;
}
@@ -702,6 +707,11 @@ export const mysqlUserAdminProvider: DatabaseUserAdminProvider = {
privilegeSelectionFromGrants: mysqlPrivilegeSelectionFromGrants,
};
export const nativeMysqlUserAdminProvider: DatabaseUserAdminProvider = {
...mysqlUserAdminProvider,
renameUserSql: mysqlRenameUserHostSql,
};
export const postgresUserAdminProvider: DatabaseUserAdminProvider = {
dialect: "postgres",
defaultScope: "database",
@@ -787,6 +797,9 @@ const DATABASE_USER_ADMIN_PROVIDER_BY_TYPE = new Map<DatabaseType, DatabaseUserA
export function getDatabaseUserAdminProvider(dbType: DatabaseType | undefined, connection?: ConnectionConfig): DatabaseUserAdminProvider | null {
if (!dbType) return null;
if (dbType === "mysql" && connection?.db_type === "mysql" && (!connection.driver_profile?.trim() || connection.driver_profile.trim().toLowerCase() === "mysql")) {
return nativeMysqlUserAdminProvider;
}
// GaussDB M mode (MySQL-compatible) uses backtick quoting and treats "user"
// as a reserved keyword, so a dedicated provider with backtick-quoted aliases
// is required.