Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Fix Metabot "Sorry, I ran into an error" on question pages (#85724)

Paolo Rascunàf3aea6c3df2a
diff --git a/frontend/src/metabase/metabot/state/actions.ts b/frontend/src/metabase/metabot/state/actions.ts
index 57f9cf2d5b8..12c5594ce86 100644
--- a/frontend/src/metabase/metabot/state/actions.ts
+++ b/frontend/src/metabase/metabot/state/actions.ts
@@ -761,6 +761,9 @@ export const sendAgentRequest = createAsyncThunk<
error,
getSetting(getState(), "metabot-name"),
);
+ if (handled.error.type === "unknown") {
+ console.error(error);
+ }
return rejectWithValue({
type: "error" as const,
conversation_id: request.conversation_id,
diff --git a/frontend/src/metabase/metabot/tests/errors.unit.spec.tsx b/frontend/src/metabase/metabot/tests/errors.unit.spec.tsx
index 43e0ff37380..f694c6cda33 100644
--- a/frontend/src/metabase/metabot/tests/errors.unit.spec.tsx
+++ b/frontend/src/metabase/metabot/tests/errors.unit.spec.tsx
@@ -33,6 +33,49 @@ describe("metabot > errors", () => {
expect(await input()).toHaveTextContent("Who is your favorite?");
});
+ it("logs an unexpected error from the agent request", async () => {
+ const consoleErrorSpy = jest
+ .spyOn(console, "error")
+ .mockImplementation(() => {});
+ const thrownError = new TypeError("Failed to fetch");
+ setup();
+ fetchMock.post(`path:/api/metabot/agent-streaming`, {
+ throws: thrownError,
+ });
+
+ try {
+ await enterChatMessage("Who is your favorite?");
+
+ await assertConversation([
+ ["user", "Who is your favorite?"],
+ ["agent", METABOT_ERR_MSG.default],
+ ]);
+ expect(consoleErrorSpy).toHaveBeenCalledWith(thrownError);
+ } finally {
+ consoleErrorSpy.mockRestore();
+ }
+ });
+
+ it("does not log the 409 conversation-out-of-sync error", async () => {
+ const consoleErrorSpy = jest
+ .spyOn(console, "error")
+ .mockImplementation(() => {});
+ setup();
+ fetchMock.post(`path:/api/metabot/agent-streaming`, 409);
+
+ try {
+ await enterChatMessage("Who is your favorite?");
+
+ await assertConversation([
+ ["user", "Who is your favorite?"],
+ ["agent", METABOT_ERR_MSG.outOfSync],
+ ]);
+ expect(consoleErrorSpy).not.toHaveBeenCalled();
+ } finally {
+ consoleErrorSpy.mockRestore();
+ }
+ });
+
it("should show a validation error message for bad requests", async () => {
setup();
fetchMock.post(`path:/api/metabot/agent-streaming`, 400);
diff --git a/frontend/src/metabase/palette/hooks/useRegisterShortcut.tsx b/frontend/src/metabase/palette/hooks/useRegisterShortcut.tsx
index d2dc55eb717..ca70ee425e7 100644
--- a/frontend/src/metabase/palette/hooks/useRegisterShortcut.tsx
+++ b/frontend/src/metabase/palette/hooks/useRegisterShortcut.tsx
@@ -1,5 +1,6 @@
import { type ActionImpl, KBarContext, useRegisterActions } from "kbar";
import { type DependencyList, useContext } from "react";
+import { useLatest } from "react-use";
import { type KeyboardShortcutId, shortcuts } from "../shortcuts";
import type { ShortcutAction } from "../types";
@@ -34,6 +35,15 @@ export const composeKeywords = (
.join(", ");
};
+/**
+ * Registers keyboard shortcuts with kbar, when a kbar provider is present.
+ *
+ * `deps` must cover the inputs of every field other than `perform`, such as
+ * `name`, `section`, `icon`, `keywords` and `shortcut`. A shortcut always runs the
+ * `perform` from the latest render, so `perform` needs no deps. A change in the
+ * list of ids registers the shortcuts again. Without a kbar provider, the hook
+ * registers nothing.
+ */
export const useRegisterShortcut = (
shortcutsToRegister: RegisterShortcutProps[],
deps: DependencyList = [],
@@ -45,9 +55,16 @@ export const useRegisterShortcut = (
// side effects
const ctx = useContext(KBarContext);
+ const latestShortcuts = useLatest(shortcutsToRegister);
+ const ids = shortcutsToRegister.map(({ id }) => id).join(",");
+
+ // kbar keeps the last action of a repeated id, so the last entry wins here too.
+ // https://github.com/timc1/kbar/blob/v0.1.0-beta.45/src/action/ActionInterface.ts
+ const findLatest = (id: KeyboardShortcutId) =>
+ latestShortcuts.current.findLast((candidate) => candidate.id === id);
const actions = ctx.query
- ? shortcutsToRegister.map(({ id, perform, ...rest }) => {
+ ? shortcutsToRegister.map(({ id, perform: _perform, ...rest }) => {
const shortcutDef = shortcuts[id];
if (shortcutDef === undefined && !rest.shortcut) {
@@ -60,7 +77,11 @@ export const useRegisterShortcut = (
...shortcutDef,
id,
perform: (action: ActionImpl, event?: KeyboardEvent) => {
- perform(action, event);
+ const shortcut = findLatest(id);
+ if (shortcut === undefined) {
+ return;
+ }
+ shortcut.perform(action, event);
if (event) {
trackKeyboardShortcutPerformed(id);
}
@@ -71,5 +92,5 @@ export const useRegisterShortcut = (
})
: [];
- useRegisterActions(actions, [...deps]);
+ useRegisterActions(actions, [...deps, ids, ctx.query]);
};
diff --git a/frontend/src/metabase/palette/hooks/useRegisterShortcut.unit.spec.tsx b/frontend/src/metabase/palette/hooks/useRegisterShortcut.unit.spec.tsx
new file mode 100644
index 00000000000..2d10eaf128b
--- /dev/null
+++ b/frontend/src/metabase/palette/hooks/useRegisterShortcut.unit.spec.tsx
@@ -0,0 +1,234 @@
+import userEvent from "@testing-library/user-event";
+import { type ActionImpl, type KBarQuery, useKBar } from "kbar";
+import type { DependencyList } from "react";
+
+import { renderWithProviders, screen } from "__support__/ui";
+
+import type { KeyboardShortcutId } from "../shortcuts";
+
+import { trackKeyboardShortcutPerformed } from "./analytics";
+import {
+ type RegisterShortcutProps,
+ useRegisterShortcut,
+} from "./useRegisterShortcut";
+
+jest.mock("./analytics");
+
+type HarnessProps = {
+ shortcutsToRegister: RegisterShortcutProps[];
+ deps?: DependencyList;
+};
+
+const Harness = ({ shortcutsToRegister, deps }: HarnessProps) => {
+ useRegisterShortcut(shortcutsToRegister, deps);
+ return null;
+};
+
+type ProbeProps = {
+ onQuery: (query: KBarQuery) => void;
+ onActions: (actions: Record<string, ActionImpl>) => void;
+};
+
+// Renders before `Harness`, so `onQuery` sees the kbar query before any
+// effect registers an action.
+const ActionNames = ({ onQuery, onActions }: ProbeProps) => {
+ const { query, actions } = useKBar((state) => ({ actions: state.actions }));
+ onQuery(query);
+ onActions(actions);
+
+ return (
+ <ul>
+ {Object.values(actions).map((action) => (
+ <li key={action.id}>{action.name}</li>
+ ))}
+ </ul>
+ );
+};
+
+type SetupOpts = HarnessProps;
+
+const setup = async ({ shortcutsToRegister, deps }: SetupOpts) => {
+ let registerActions:
+ | jest.SpiedFunction<KBarQuery["registerActions"]>
+ | undefined;
+ const onQuery = (query: KBarQuery) => {
+ registerActions ??= jest.spyOn(query, "registerActions");
+ };
+ const registeredActions = new Map<string, ActionImpl>();
+ const onActions = (actions: Record<string, ActionImpl>) => {
+ Object.values(actions).forEach((action) =>
+ registeredActions.set(action.id, action),
+ );
+ };
+
+ const ui = (props: HarnessProps) => (
+ <>
+ <ActionNames onQuery={onQuery} onActions={onActions} />
+ <Harness {...props} />
+ </>
+ );
+
+ const { rerender } = renderWithProviders(ui({ shortcutsToRegister, deps }), {
+ withKBar: true,
+ });
+
+ await screen.findByRole("list");
+
+ return {
+ rerender: (props: HarnessProps) => rerender(ui(props)),
+ getRegisterActions: () => registerActions,
+ getRegisteredAction: (id: string) => registeredActions.get(id),
+ };
+};
+
+const toggleNavbar = (
+ perform: RegisterShortcutProps["perform"],
+ overrides: Partial<RegisterShortcutProps> = {},
+): RegisterShortcutProps => ({ id: "toggle-navbar", perform, ...overrides });
+
+const mockPerform = () =>
+ jest.fn<void, Parameters<RegisterShortcutProps["perform"]>>();
+
+// `[[` types one `[`, the key of the "toggle-navbar" shortcut.
+const pressToggleNavbarKey = () => userEvent.keyboard("[[");
+
+describe("useRegisterShortcut", () => {
+ afterEach(() => {
+ jest.clearAllMocks();
+ jest.restoreAllMocks();
+ });
+
+ it("runs the latest perform after a re-render", async () => {
+ const firstPerform = mockPerform();
+ const latestPerform = mockPerform();
+ const { rerender, getRegisterActions } = await setup({
+ shortcutsToRegister: [toggleNavbar(firstPerform)],
+ deps: [],
+ });
+
+ rerender({ shortcutsToRegister: [toggleNavbar(latestPerform)], deps: [] });
+ await pressToggleNavbarKey();
+
+ expect(latestPerform).toHaveBeenCalledTimes(1);
+ expect(firstPerform).not.toHaveBeenCalled();
+ expect(getRegisterActions()).toHaveBeenCalledTimes(1);
+ });
+
+ it("registers again when the list of ids changes", async () => {
+ const perform = mockPerform();
+ const { rerender } = await setup({ shortcutsToRegister: [], deps: [] });
+ expect(screen.queryByText("Toggle sidebar")).not.toBeInTheDocument();
+
+ rerender({ shortcutsToRegister: [toggleNavbar(perform)], deps: [] });
+ expect(await screen.findByText("Toggle sidebar")).toBeInTheDocument();
+ await pressToggleNavbarKey();
+ expect(perform).toHaveBeenCalledTimes(1);
+
+ rerender({ shortcutsToRegister: [], deps: [] });
+ expect(screen.queryByText("Toggle sidebar")).not.toBeInTheDocument();
+ });
+
+ it("registers again when a dep and the name change", async () => {
+ const perform = mockPerform();
+ const { rerender } = await setup({
+ shortcutsToRegister: [toggleNavbar(perform, { name: "First name" })],
+ deps: ["First name"],
+ });
+ expect(screen.getByText("First name")).toBeInTheDocument();
+
+ rerender({
+ shortcutsToRegister: [toggleNavbar(perform, { name: "Second name" })],
+ deps: ["Second name"],
+ });
+
+ expect(await screen.findByText("Second name")).toBeInTheDocument();
+ expect(screen.queryByText("First name")).not.toBeInTheDocument();
+ });
+
+ it("does not register again when only the name changes without a dep", async () => {
+ const perform = mockPerform();
+ const { rerender, getRegisterActions } = await setup({
+ shortcutsToRegister: [toggleNavbar(perform, { name: "First name" })],
+ deps: [],
+ });
+
+ rerender({
+ shortcutsToRegister: [toggleNavbar(perform, { name: "Second name" })],
+ deps: [],
+ });
+
+ expect(screen.getByText("First name")).toBeInTheDocument();
+ expect(screen.queryByText("Second name")).not.toBeInTheDocument();
+ expect(getRegisterActions()).toHaveBeenCalledTimes(1);
+ });
+
+ it("runs the perform of the last entry when an id repeats", async () => {
+ const firstPerform = mockPerform();
+ const lastPerform = mockPerform();
+ await setup({
+ shortcutsToRegister: [
+ toggleNavbar(firstPerform),
+ toggleNavbar(lastPerform),
+ ],
+ });
+
+ await pressToggleNavbarKey();
+
+ expect(lastPerform).toHaveBeenCalledTimes(1);
+ expect(firstPerform).not.toHaveBeenCalled();
+ });
+
+ it("tracks a shortcut that runs from the keyboard", async () => {
+ const perform = mockPerform();
+ await setup({ shortcutsToRegister: [toggleNavbar(perform)] });
+
+ await pressToggleNavbarKey();
+
+ expect(perform).toHaveBeenCalledTimes(1);
+ expect(trackKeyboardShortcutPerformed).toHaveBeenCalledTimes(1);
+ expect(trackKeyboardShortcutPerformed).toHaveBeenCalledWith(
+ "toggle-navbar",
+ );
+ });
+
+ it("does not track a key press when the latest render dropped the id", async () => {
+ const perform = mockPerform();
+ const { rerender, getRegisteredAction } = await setup({
+ shortcutsToRegister: [toggleNavbar(perform)],
+ });
+ // kbar can still hold this action after a render drops its id, until the
+ // effect cleanup unregisters it.
+ const staleAction = getRegisteredAction("toggle-navbar");
+ expect(staleAction).toBeDefined();
+
+ rerender({ shortcutsToRegister: [] });
+ staleAction?.command?.perform(new KeyboardEvent("keydown"));
+
+ expect(perform).not.toHaveBeenCalled();
+ expect(trackKeyboardShortcutPerformed).not.toHaveBeenCalled();
+ });
+
+ it("does not throw without a kbar provider", () => {
+ const perform = mockPerform();
+
+ expect(() =>
+ renderWithProviders(
+ <Harness shortcutsToRegister={[toggleNavbar(perform)]} />,
+ ),
+ ).not.toThrow();
+ });
+
+ it("throws for an unknown id without a shortcut", () => {
+ jest.spyOn(console, "error").mockImplementation(() => undefined);
+ // The type rules out unknown ids. The cast reaches the runtime check
+ // that protects untyped callers.
+ const id = "unknown-shortcut" as KeyboardShortcutId;
+
+ expect(() =>
+ renderWithProviders(
+ <Harness shortcutsToRegister={[{ id, perform: mockPerform() }]} />,
+ { withKBar: true },
+ ),
+ ).toThrow("Unrecognized shortcut id unknown-shortcut");
+ });
+});
diff --git a/frontend/src/metabase/query_builder/components/view/QuestionDisplayToggle/QuestionDisplayToggle.tsx b/frontend/src/metabase/query_builder/components/view/QuestionDisplayToggle/QuestionDisplayToggle.tsx
index 0810cf3325c..c479bf3db0d 100644
--- a/frontend/src/metabase/query_builder/components/view/QuestionDisplayToggle/QuestionDisplayToggle.tsx
+++ b/frontend/src/metabase/query_builder/components/view/QuestionDisplayToggle/QuestionDisplayToggle.tsx
@@ -14,15 +14,12 @@ export const QuestionDisplayToggle = ({
isShowingRawTable,
onToggleRawTable,
}: QuestionDisplayToggleProps) => {
- useRegisterShortcut(
- [
- {
- id: "query-builder-toggle-visualization",
- perform: () => onToggleRawTable(!isShowingRawTable),
- },
- ],
- [isShowingRawTable, onToggleRawTable],
- );
+ useRegisterShortcut([
+ {
+ id: "query-builder-toggle-visualization",
+ perform: () => onToggleRawTable(!isShowingRawTable),
+ },
+ ]);
return (
<SegmentedControl
diff --git a/frontend/src/metabase/query_builder/components/view/QuestionDisplayToggle/QuestionDisplayToggle.unit.spec.tsx b/frontend/src/metabase/query_builder/components/view/QuestionDisplayToggle/QuestionDisplayToggle.unit.spec.tsx
index 6a76833c82e..801378baecf 100644
--- a/frontend/src/metabase/query_builder/components/view/QuestionDisplayToggle/QuestionDisplayToggle.unit.spec.tsx
+++ b/frontend/src/metabase/query_builder/components/view/QuestionDisplayToggle/QuestionDisplayToggle.unit.spec.tsx
@@ -1,8 +1,50 @@
import userEvent from "@testing-library/user-event";
+import { type KBarQuery, useKBar } from "kbar";
import { renderWithProviders, screen } from "__support__/ui";
-import { QuestionDisplayToggle } from "./QuestionDisplayToggle";
+import {
+ QuestionDisplayToggle,
+ type QuestionDisplayToggleProps,
+} from "./QuestionDisplayToggle";
+
+type ProbeProps = {
+ onQuery: (query: KBarQuery) => void;
+};
+
+// Renders before the toggle, so `onQuery` sees the kbar query before the
+// toggle's first effect registers the shortcut.
+const KBarQueryProbe = ({ onQuery }: ProbeProps) => {
+ const { query } = useKBar();
+ onQuery(query);
+ return null;
+};
+
+const setupWithKBar = (props: QuestionDisplayToggleProps) => {
+ let registerActions:
+ | jest.SpiedFunction<KBarQuery["registerActions"]>
+ | undefined;
+ const onQuery = (query: KBarQuery) => {
+ registerActions ??= jest.spyOn(query, "registerActions");
+ };
+
+ const ui = (props: QuestionDisplayToggleProps) => (
+ <>
+ <KBarQueryProbe onQuery={onQuery} />
+ <QuestionDisplayToggle {...props} />
+ </>
+ );
+
+ const { rerender } = renderWithProviders(ui(props), { withKBar: true });
+
+ return {
+ rerender: (props: QuestionDisplayToggleProps) => rerender(ui(props)),
+ getRegisterActions: () => registerActions,
+ };
+};
+
+// `v` is the key of the "query-builder-toggle-visualization" shortcut.
+const pressToggleVisualizationKey = () => userEvent.keyboard("v");
describe("QuestionDisplayToggle", () => {
it("renders correctly", () => {
@@ -73,4 +115,42 @@ describe("QuestionDisplayToggle", () => {
await userEvent.type(button, " ");
expect(onToggleRawTable).toHaveBeenCalledWith(false);
});
+
+ describe("keyboard shortcut", () => {
+ afterEach(() => {
+ jest.restoreAllMocks();
+ });
+
+ it("registers the shortcut once when the toggle renders again", () => {
+ const { rerender, getRegisterActions } = setupWithKBar({
+ isShowingRawTable: false,
+ onToggleRawTable: () => undefined,
+ });
+ expect(getRegisterActions()).toHaveBeenCalledTimes(1);
+ getRegisterActions()?.mockClear();
+
+ rerender({ isShowingRawTable: false, onToggleRawTable: () => undefined });
+
+ expect(getRegisterActions()).not.toHaveBeenCalled();
+ });
+
+ it("the shortcut uses the latest props", async () => {
+ const firstOnToggleRawTable = jest.fn<void, [boolean]>();
+ const latestOnToggleRawTable = jest.fn<void, [boolean]>();
+ const { rerender } = setupWithKBar({
+ isShowingRawTable: false,
+ onToggleRawTable: firstOnToggleRawTable,
+ });
+
+ rerender({
+ isShowingRawTable: true,
+ onToggleRawTable: latestOnToggleRawTable,
+ });
+ await pressToggleVisualizationKey();
+
+ expect(latestOnToggleRawTable).toHaveBeenCalledTimes(1);
+ expect(latestOnToggleRawTable).toHaveBeenCalledWith(false);
+ expect(firstOnToggleRawTable).not.toHaveBeenCalled();
+ });
+ });
});
diff --git a/frontend/src/metabase/query_builder/components/view/ViewFooter/CenterViewFooterButtonGroup.tsx b/frontend/src/metabase/query_builder/components/view/ViewFooter/CenterViewFooterButtonGroup.tsx
index aad0a849970..584891e59d2 100644
--- a/frontend/src/metabase/query_builder/components/view/ViewFooter/CenterViewFooterButtonGroup.tsx
+++ b/frontend/src/metabase/query_builder/components/view/ViewFooter/CenterViewFooterButtonGroup.tsx
@@ -1,3 +1,5 @@
+import { useCallback } from "react";
+
import CS from "metabase/css/core/index.css";
import { useDispatch, useSelector } from "metabase/redux";
import { setUIControls } from "metabase/redux/query-builder";
@@ -8,13 +10,18 @@ import { QuestionDisplayToggle } from "../QuestionDisplayToggle/QuestionDisplayT
export const CenterViewFooterButtonGroup = () => {
const dispatch = useDispatch();
const { isShowingRawTable } = useSelector(getUiControls);
+ const handleToggleRawTable = useCallback(
+ (isShowingRawTable: boolean) => {
+ dispatch(setUIControls({ isShowingRawTable }));
+ },
+ [dispatch],
+ );
+
return (
<QuestionDisplayToggle
className={CS.mx1}
isShowingRawTable={isShowingRawTable}
- onToggleRawTable={(isShowingRawTable) => {
- dispatch(setUIControls({ isShowingRawTable }));
- }}
+ onToggleRawTable={handleToggleRawTable}
/>
);
};