Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix(frontend): fill project pages after permission filtering (#21564)

p0ny7561eeea96b4
diff --git a/frontend/src/components/AdvancedSearch.test.tsx b/frontend/src/components/AdvancedSearch.test.tsx
index 9d1747b3a8..c31f79a6ba 100644
--- a/frontend/src/components/AdvancedSearch.test.tsx
+++ b/frontend/src/components/AdvancedSearch.test.tsx
@@ -1,4 +1,4 @@
-import { fireEvent, render, screen } from "@testing-library/react";
+import { act, fireEvent, render, screen } from "@testing-library/react";
import { describe, expect, test, vi } from "vitest";
import { AdvancedSearch, emptySearchParams } from "./AdvancedSearch";
@@ -22,6 +22,38 @@ globalThis.ResizeObserver =
ResizeObserverMock as unknown as typeof ResizeObserver;
describe("AdvancedSearch", () => {
+ test("cancels obsolete scope searches and aborts on unmount", async () => {
+ vi.useFakeTimers();
+ const signals: AbortSignal[] = [];
+ const onSearch = vi.fn(async (_keyword: string, signal?: AbortSignal) => {
+ signals.push(signal!);
+ return [];
+ });
+ try {
+ const view = render(
+ <AdvancedSearch
+ params={emptySearchParams()}
+ scopeOptions={[{ id: "project", title: "project", onSearch }]}
+ onParamsChange={vi.fn()}
+ />
+ );
+ fireEvent.click(screen.getByRole("textbox"));
+ fireEvent.click(screen.getByText("project"));
+ await act(() => vi.advanceTimersByTimeAsync(1000));
+ expect(signals).toHaveLength(1);
+ fireEvent.change(screen.getByRole("textbox"), {
+ target: { value: "project:new" },
+ });
+ expect(signals[0].aborted).toBe(true);
+ await act(() => vi.advanceTimersByTimeAsync(1000));
+ expect(signals).toHaveLength(2);
+ view.unmount();
+ expect(signals[1].aborted).toBe(true);
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+
test("renders a default placeholder when none is provided", () => {
render(
<AdvancedSearch
diff --git a/frontend/src/components/AdvancedSearch.tsx b/frontend/src/components/AdvancedSearch.tsx
index 1bce5433e5..373ff0748b 100644
--- a/frontend/src/components/AdvancedSearch.tsx
+++ b/frontend/src/components/AdvancedSearch.tsx
@@ -41,7 +41,7 @@ export interface ScopeOption {
options?: ValueOption[];
allowMultiple?: boolean;
/** Server-side search callback. When provided, options are fetched dynamically instead of filtered client-side. */
- onSearch?: (keyword: string) => Promise<ValueOption[]>;
+ onSearch?: (keyword: string, signal?: AbortSignal) => Promise<ValueOption[]>;
}
export function emptySearchParams(): SearchParams {
@@ -291,32 +291,47 @@ export function AdvancedSearch({
}
const requestID = asyncRequestRef.current;
+ const controller = new AbortController();
setAsyncLoading(true);
asyncSearchRef.current = setTimeout(() => {
const fn = onSearchRef.current;
if (!fn) {
- if (asyncRequestRef.current !== requestID) return;
+ if (controller.signal.aborted || asyncRequestRef.current !== requestID)
+ return;
setAsyncOptions([]);
setAsyncLoading(false);
return;
}
- fn(currentValueForScope)
+ fn(currentValueForScope, controller.signal)
.then((results) => {
- if (asyncRequestRef.current !== requestID) return;
+ if (
+ controller.signal.aborted ||
+ asyncRequestRef.current !== requestID
+ )
+ return;
setAsyncOptions(results);
setMenuIndex(0);
})
.catch(() => {
- if (asyncRequestRef.current !== requestID) return;
+ if (
+ controller.signal.aborted ||
+ asyncRequestRef.current !== requestID
+ )
+ return;
setAsyncOptions([]);
})
.finally(() => {
- if (asyncRequestRef.current !== requestID) return;
+ if (
+ controller.signal.aborted ||
+ asyncRequestRef.current !== requestID
+ )
+ return;
setAsyncLoading(false);
});
}, DEBOUNCE_SEARCH_DELAY);
return () => {
clearTimeout(asyncSearchRef.current);
+ controller.abort();
};
}, [currentScope, currentValueForScope]);
diff --git a/frontend/src/components/ExprEditor.test.tsx b/frontend/src/components/ExprEditor.test.tsx
index c4a028163d..e171738af2 100644
--- a/frontend/src/components/ExprEditor.test.tsx
+++ b/frontend/src/components/ExprEditor.test.tsx
@@ -1,5 +1,6 @@
import * as stylex from "@stylexjs/stylex";
-import { act, type ReactElement, useState } from "react";
+import { fireEvent, waitFor } from "@testing-library/react";
+import { act, type ReactElement, StrictMode, useState } from "react";
import { createRoot } from "react-dom/client";
import { afterEach, describe, expect, test, vi } from "vitest";
import type { Factor } from "@/modules/cel/types/factor";
@@ -162,6 +163,76 @@ describe("ExprEditor", () => {
document.body.innerHTML = "";
});
+ test.each(["_==_", "@in"] as const)(
+ "cancels replaced searches and survives StrictMode replay for %s",
+ async (operator) => {
+ const signals: AbortSignal[] = [];
+ const config: OptionConfig = {
+ options: [],
+ search: async ({ signal }) => {
+ signals.push(signal!);
+ return { options: [], nextPageToken: "" };
+ },
+ };
+ const { container, unmount } = renderIntoContainer(
+ <StrictMode>
+ <ExprEditor
+ expr={{
+ type: ExprType.ConditionGroup,
+ operator: "_&&_",
+ args: [
+ operator === "@in"
+ ? {
+ type: ExprType.Condition,
+ operator,
+ args: [CEL_ATTRIBUTE_RESOURCE_DATABASE, ["selected"]],
+ }
+ : {
+ type: ExprType.Condition,
+ operator,
+ args: [CEL_ATTRIBUTE_RESOURCE_DATABASE, "selected"],
+ },
+ ],
+ }}
+ factorList={[CEL_ATTRIBUTE_RESOURCE_DATABASE]}
+ optionConfigMap={
+ new Map([[CEL_ATTRIBUTE_RESOURCE_DATABASE, config]])
+ }
+ onUpdate={() => {}}
+ />
+ </StrictMode>
+ );
+ await flushEffects();
+ expect(signals).toHaveLength(2);
+ expect(signals[0].aborted).toBe(true);
+ expect(signals[1].aborted).toBe(false);
+ const trigger =
+ operator === "@in"
+ ? Array.from(container.querySelectorAll("div")).find((el) =>
+ el.className.includes("cursor-pointer")
+ )
+ : Array.from(container.querySelectorAll("button")).find(
+ (el) => el.textContent === "selected"
+ );
+ expect(trigger).toBeTruthy();
+ await act(async () => {
+ fireEvent.click(trigger!);
+ });
+ expect(signals[1].aborted).toBe(true);
+ const input = document.querySelector(
+ 'input[placeholder="common.filter-by-name"]'
+ );
+ expect(input).toBeTruthy();
+ await act(async () => {
+ fireEvent.change(input!, { target: { value: "new" } });
+ });
+ await waitFor(() => expect(signals[2].aborted).toBe(true));
+ expect(signals[3].aborted).toBe(false);
+ unmount();
+ expect(signals[3].aborted).toBe(true);
+ }
+ );
+
test("keeps the next condition value after deleting the first condition", async () => {
const initialExpr: ConditionGroupExpr = {
type: ExprType.ConditionGroup,
diff --git a/frontend/src/components/ExprEditor.tsx b/frontend/src/components/ExprEditor.tsx
index 57500b8532..f0b4603d76 100644
--- a/frontend/src/components/ExprEditor.tsx
+++ b/frontend/src/components/ExprEditor.tsx
@@ -288,19 +288,28 @@ function SearchableSelect({
return value || "";
}, [options, value, optionConfig]);
+ const searchControllerRef = useRef<AbortController | null>(null);
+ useEffect(() => () => searchControllerRef.current?.abort(), []);
const doSearch = useCallback(
async (q: string) => {
if (!optionConfig.search) return;
+ searchControllerRef.current?.abort();
+ const controller = new AbortController();
+ searchControllerRef.current = controller;
setLoading(true);
try {
const resp = await optionConfig.search({
+ signal: controller.signal,
search: q,
pageToken: "",
pageSize: getDefaultPagination(),
});
- setOptions(resp.options as SearchableSelectOption[]);
+ if (!controller.signal.aborted)
+ setOptions(resp.options as SearchableSelectOption[]);
+ } catch (error) {
+ if (!controller.signal.aborted) throw error;
} finally {
- setLoading(false);
+ if (!controller.signal.aborted) setLoading(false);
}
},
[optionConfig]
@@ -308,7 +317,8 @@ function SearchableSelect({
const initializedRef = useRef(false);
useEffect(() => {
- if (initializedRef.current) return;
+ if (initializedRef.current && !searchControllerRef.current?.signal.aborted)
+ return;
initializedRef.current = true;
if (!value) return;
if (optionConfig.fetch) {
@@ -474,19 +484,28 @@ function MultiSearchableSelect({
[allOptions, optionConfig]
);
+ const searchControllerRef = useRef<AbortController | null>(null);
+ useEffect(() => () => searchControllerRef.current?.abort(), []);
const doSearch = useCallback(
async (q: string) => {
if (!optionConfig.search) return;
+ searchControllerRef.current?.abort();
+ const controller = new AbortController();
+ searchControllerRef.current = controller;
setLoading(true);
try {
const resp = await optionConfig.search({
+ signal: controller.signal,
search: q,
pageToken: "",
pageSize: getDefaultPagination(),
});
- setSearchOptions(resp.options as SearchableSelectOption[]);
+ if (!controller.signal.aborted)
+ setSearchOptions(resp.options as SearchableSelectOption[]);
+ } catch (error) {
+ if (!controller.signal.aborted) throw error;
} finally {
- setLoading(false);
+ if (!controller.signal.aborted) setLoading(false);
}
},
[optionConfig]
@@ -494,7 +513,8 @@ function MultiSearchableSelect({
const multiInitRef = useRef(false);
useEffect(() => {
- if (multiInitRef.current) return;
+ if (multiInitRef.current && !searchControllerRef.current?.signal.aborted)
+ return;
multiInitRef.current = true;
if (value.length === 0) return;
if (optionConfig.fetch) {
diff --git a/frontend/src/components/ProjectSelect.test.tsx b/frontend/src/components/ProjectSelect.test.tsx
new file mode 100644
index 0000000000..64383e1154
--- /dev/null
+++ b/frontend/src/components/ProjectSelect.test.tsx
@@ -0,0 +1,49 @@
+import { act, render } from "@testing-library/react";
+import { StrictMode } from "react";
+import { expect, test, vi } from "vitest";
+import { ProjectSelect } from "./ProjectSelect";
+
+const mocks = vi.hoisted(() => ({
+ fetchProjectList: vi.fn(async () => ({ projects: [], nextPageToken: "" })),
+ search: undefined as ((query: string) => Promise<void>) | undefined,
+}));
+vi.mock("@/stores/app", () => ({
+ useAppStore: {
+ getState: () => ({ fetchProjectList: mocks.fetchProjectList }),
+ },
+}));
+vi.mock("@/components/ui/combobox", () => ({
+ Combobox: ({ onSearch }: { onSearch: (query: string) => Promise<void> }) => {
+ mocks.search = onSearch;
+ return null;
+ },
+}));
+vi.mock("react-i18next", () => ({
+ initReactI18next: { type: "3rdParty", init: () => {} },
+ useTranslation: () => ({ t: (key: string) => key }),
+}));
+
+test("forwards search cancellation through StrictMode replay, replacement, and unmount", async () => {
+ const signals: AbortSignal[] = [];
+ mocks.fetchProjectList.mockImplementation(
+ async (params?: { signal?: AbortSignal }) => {
+ expect(params?.signal).toBeInstanceOf(AbortSignal);
+ signals.push(params!.signal!);
+ return { projects: [], nextPageToken: "" };
+ }
+ );
+ const view = render(
+ <StrictMode>
+ <ProjectSelect value="" onChange={() => {}} />
+ </StrictMode>
+ );
+ await act(async () => {});
+ expect(signals).toHaveLength(2);
+ expect(signals[0].aborted).toBe(true);
+ expect(signals[1].aborted).toBe(false);
+ await act(() => mocks.search!("new"));
+ expect(signals[1].aborted).toBe(true);
+ expect(signals[2].aborted).toBe(false);
+ view.unmount();
+ expect(signals[2].aborted).toBe(true);
+});
diff --git a/frontend/src/components/ProjectSelect.tsx b/frontend/src/components/ProjectSelect.tsx
index 8b7a7f69cd..68c5446cb1 100644
--- a/frontend/src/components/ProjectSelect.tsx
+++ b/frontend/src/components/ProjectSelect.tsx
@@ -55,17 +55,21 @@ export function ProjectSelect({
const excludeDefaultRef = useRef(excludeDefault);
excludeDefaultRef.current = excludeDefault;
- const fetchPage = useCallback(async (query: string, pageToken: string) => {
- const result = await useAppStore.getState().fetchProjectList({
- filter: { query, excludeDefault: excludeDefaultRef.current },
- pageSize: getDefaultPagination(),
- pageToken,
- });
- return {
- items: result.projects,
- nextPageToken: result.nextPageToken,
- };
- }, []);
+ const fetchPage = useCallback(
+ async (query: string, pageToken: string, signal: AbortSignal) => {
+ const result = await useAppStore.getState().fetchProjectList({
+ signal,
+ filter: { query, excludeDefault: excludeDefaultRef.current },
+ pageSize: getDefaultPagination(),
+ pageToken,
+ });
+ return {
+ items: result.projects,
+ nextPageToken: result.nextPageToken,
+ };
+ },
+ []
+ );
const {
items: projects,
search,
diff --git a/frontend/src/components/instance/InstanceDetailView.tsx b/frontend/src/components/instance/InstanceDetailView.tsx
index d6b70dd67a..051db13079 100644
--- a/frontend/src/components/instance/InstanceDetailView.tsx
+++ b/frontend/src/components/instance/InstanceDetailView.tsx
@@ -415,8 +415,9 @@ export function InstanceDetailView({
[defaultProjectId, t]
);
const searchProjects = useCallback(
- async (keyword: string): Promise<ValueOption[]> => {
+ async (keyword: string, signal?: AbortSignal): Promise<ValueOption[]> => {
const { projects } = await useAppStore.getState().fetchProjectList({
+ signal,
pageSize: getDefaultPagination(),
filter: keyword.trim() ? { query: keyword } : undefined,
});
@@ -504,26 +505,27 @@ export function InstanceDetailView({
return;
}
- let cancelled = false;
+ const controller = new AbortController();
void (async () => {
try {
const { projects } = await useAppStore.getState().fetchProjectList({
+ signal: controller.signal,
pageSize: getDefaultPagination(),
silent: true,
});
- if (cancelled) {
+ if (controller.signal.aborted) {
return;
}
setHasUserProject(projects.some(isUserProject));
} catch {
- if (!cancelled) {
+ if (!controller.signal.aborted) {
setHasUserProject(false);
}
}
})();
return () => {
- cancelled = true;
+ controller.abort();
};
}, [
defaultProjectName,
diff --git a/frontend/src/components/sql-review/Panels.test.tsx b/frontend/src/components/sql-review/Panels.test.tsx
index 6de7edd058..90278facd5 100644
--- a/frontend/src/components/sql-review/Panels.test.tsx
+++ b/frontend/src/components/sql-review/Panels.test.tsx
@@ -188,6 +188,7 @@ describe("AttachResourcesPanel", () => {
render();
expect(mocks.fetchProjectList).toHaveBeenCalledWith({
+ signal: expect.any(AbortSignal),
cache: true,
filter: { excludeDefault: true },
});
diff --git a/frontend/src/components/sql-review/Panels.tsx b/frontend/src/components/sql-review/Panels.tsx
index 639843cd3a..a11d40ca7c 100644
--- a/frontend/src/components/sql-review/Panels.tsx
+++ b/frontend/src/components/sql-review/Panels.tsx
@@ -389,9 +389,18 @@ export function AttachResourcesPanel({
// Fetch projects on mount so the checkbox list is populated
useEffect(() => {
- useAppStore
+ const controller = new AbortController();
+ void useAppStore
.getState()
- .fetchProjectList({ cache: true, filter: { excludeDefault: true } });
+ .fetchProjectList({
+ signal: controller.signal,
+ cache: true,
+ filter: { excludeDefault: true },
+ })
+ .catch((error) => {
+ if (!controller.signal.aborted) console.error(error);
+ });
+ return () => controller.abort();
}, []);
useEffect(() => {
diff --git a/frontend/src/hooks/usePaginatedSelect.test.tsx b/frontend/src/hooks/usePaginatedSelect.test.tsx
index 215cdefd92..54ad06393a 100644
--- a/frontend/src/hooks/usePaginatedSelect.test.tsx
+++ b/frontend/src/hooks/usePaginatedSelect.test.tsx
@@ -25,14 +25,22 @@ describe("usePaginatedSelect", () => {
expect(result.current.hasMore).toBe(true);
await act(() => result.current.loadMore());
- expect(fetchPage).toHaveBeenLastCalledWith("", "page-2");
+ expect(fetchPage).toHaveBeenLastCalledWith(
+ "",
+ "page-2",
+ expect.any(AbortSignal)
+ );
expect(result.current.items.map((item) => item.name)).toEqual([
"one",
"two",
]);
await act(() => result.current.search("search"));
- expect(fetchPage).toHaveBeenLastCalledWith("search", "");
+ expect(fetchPage).toHaveBeenLastCalledWith(
+ "search",
+ "",
+ expect.any(AbortSignal)
+ );
expect(result.current.items.map((item) => item.name)).toEqual(["search"]);
expect(result.current.hasMore).toBe(true);
});
@@ -60,7 +68,9 @@ describe("usePaginatedSelect", () => {
act(() => {
oldRequest = result.current.search("old");
});
+ const oldSignal = fetchPage.mock.calls[0][2] as AbortSignal;
await act(() => result.current.search("new"));
+ expect(oldSignal.aborted).toBe(true);
await act(async () => {
resolveOld({ items: [{ name: "old" }], nextPageToken: "" });
await oldRequest;
@@ -68,4 +78,39 @@ describe("usePaginatedSelect", () => {
expect(result.current.items.map((item) => item.name)).toEqual(["new"]);
});
+ test("cancels load more on a new search and cancels on unmount", async () => {
+ let resolvePage: (value: { items: { name: string }[] }) => void = () => {};
+ const fetchPage = vi
+ .fn()
+ .mockResolvedValueOnce({
+ items: [{ name: "first" }],
+ nextPageToken: "next",
+ })
+ .mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ resolvePage = resolve;
+ })
+ )
+ .mockResolvedValueOnce({ items: [{ name: "replacement" }] });
+ const { result, unmount } = renderHook(() =>
+ usePaginatedSelect({ fetchPage })
+ );
+ await act(() => result.current.search("old"));
+ let pending: Promise<void>;
+ act(() => {
+ pending = result.current.loadMore();
+ });
+ const signal = fetchPage.mock.calls[1][2] as AbortSignal;
+ await act(() => result.current.search("new"));
+ expect(signal.aborted).toBe(true);
+ await act(async () => {
+ resolvePage({ items: [{ name: "stale" }] });
+ await pending;
+ });
+ expect(result.current.items).toEqual([{ name: "replacement" }]);
+ const currentSignal = fetchPage.mock.calls[2][2] as AbortSignal;
+ unmount();
+ expect(currentSignal.aborted).toBe(true);
+ });
});
diff --git a/frontend/src/hooks/usePaginatedSelect.ts b/frontend/src/hooks/usePaginatedSelect.ts
index ac7ae30f2f..9f4f42bd58 100644
--- a/frontend/src/hooks/usePaginatedSelect.ts
+++ b/frontend/src/hooks/usePaginatedSelect.ts
@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
interface Page<T> {
items: T[];
@@ -6,7 +6,11 @@ interface Page<T> {
}
interface UsePaginatedSelectOptions<T> {
- fetchPage: (query: string, pageToken: string) => Promise<Page<T>>;
+ fetchPage: (
+ query: string,
+ pageToken: string,
+ signal: AbortSignal
+ ) => Promise<Page<T>>;
}
export function usePaginatedSelect<T extends { name: string }>({
@@ -17,16 +21,25 @@ export function usePaginatedSelect<T extends { name: string }>({
const [loadingMore, setLoadingMore] = useState(false);
const queryRef = useRef("");
const requestGenerationRef = useRef(0);
+ const controllerRef = useRef<AbortController | null>(null);
+ useEffect(() => () => controllerRef.current?.abort(), []);
const search = useCallback(
async (query: string) => {
+ controllerRef.current?.abort();
+ const controller = new AbortController();
+ controllerRef.current = controller;
const generation = ++requestGenerationRef.current;
queryRef.current = query;
setNextPageToken("");
setLoadingMore(false);
try {
- const response = await fetchPage(query, "");
- if (generation !== requestGenerationRef.current) return;
+ const response = await fetchPage(query, "", controller.signal);
+ if (
+ controller.signal.aborted ||
+ generation !== requestGenerationRef.current
+ )
+ return;
setItems(response.items);
setNextPageToken(response.nextPageToken ?? "");
} catch {
@@ -38,11 +51,22 @@ export function usePaginatedSelect<T extends { name: string }>({
const loadMore = useCallback(async () => {
if (!nextPageToken || loadingMore) return;
+ controllerRef.current?.abort();
+ const controller = new AbortController();
+ controllerRef.current = controller;
const generation = requestGenerationRef.current;
setLoadingMore(true);
try {
- const response = await fetchPage(queryRef.current, nextPageToken);
- if (generation !== requestGenerationRef.current) return;
+ const response = await fetchPage(
+ queryRef.current,
+ nextPageToken,
+ controller.signal
+ );
+ if (
+ controller.signal.aborted ||
+ generation !== requestGenerationRef.current
+ )
+ return;
setItems((previous) => {
const names = new Set(previous.map((item) => item.name));
return [
@@ -54,7 +78,10 @@ export function usePaginatedSelect<T extends { name: string }>({
} catch {
// Keep the current page and token so the request can be retried.
} finally {
- if (generation === requestGenerationRef.current) {
+ if (
+ !controller.signal.aborted &&
+ generation === requestGenerationRef.current
+ ) {
setLoadingMore(false);
}
}
diff --git a/frontend/src/modules/workspace-setup-guide/useGuideContext.ts b/frontend/src/modules/workspace-setup-guide/useGuideContext.ts
index 33872620e0..e637a2f383 100644
--- a/frontend/src/modules/workspace-setup-guide/useGuideContext.ts
+++ b/frontend/src/modules/workspace-setup-guide/useGuideContext.ts
@@ -314,14 +314,17 @@ export const useGuideContext = ({
return;
}
+ const controller = new AbortController();
void (async () => {
const store = useAppStore.getState();
try {
const projectResponse = await store.fetchProjectList({
+ signal: controller.signal,
pageSize: 1,
silent: true,
filter: { excludeDefault: true, state: State.ACTIVE },
});
+ if (controller.signal.aborted) return;
const project = projectResponse.projects.find(
({ name }) => !!name && name !== defaultProject
);
@@ -389,6 +392,7 @@ export const useGuideContext = ({
: undefined,
])
: [];
+ if (controller.signal.aborted) return;
const eventTarget = eventTargetRef.current;
setFacts((state) => ({
@@ -416,6 +420,7 @@ export const useGuideContext = ({
),
}));
} catch {
+ if (controller.signal.aborted) return;
setFacts((state) => ({
...state,
hasExploredDatabase: databaseExplored || state.hasExploredDatabase,
@@ -426,6 +431,7 @@ export const useGuideContext = ({
}
setContextReady(true);
})();
+ return () => controller.abort();
}, [
changeIssueCreated,
databaseCacheSize,
diff --git a/frontend/src/routes/workspace/DatabasesPage.tsx b/frontend/src/routes/workspace/DatabasesPage.tsx
index c8257471a9..a77d9edaac 100644
--- a/frontend/src/routes/workspace/DatabasesPage.tsx
+++ b/frontend/src/routes/workspace/DatabasesPage.tsx
@@ -135,8 +135,9 @@ export function DatabasesPage() {
[defaultProjectId, t]
);
const searchProjects = useCallback(
- async (keyword: string): Promise<ValueOption[]> => {
+ async (keyword: string, signal?: AbortSignal): Promise<ValueOption[]> => {
const { projects } = await useAppStore.getState().fetchProjectList({
+ signal,
pageSize: getDefaultPagination(),
filter: keyword.trim() ? { query: keyword } : undefined,
});
@@ -154,7 +155,7 @@ export function DatabasesPage() {
);
const searchInstances = useCallback(
- async (keyword: string): Promise<ValueOption[]> => {
+ async (keyword: string, signal?: AbortSignal): Promise<ValueOption[]> => {
if (!hasWorkspacePermissionV2("bb.instances.list")) return [];
const { instances } = await useAppStore.getState().fetchInstanceList({
pageSize: getDefaultPagination(),
diff --git a/frontend/src/routes/workspace/ProjectsPage.test.tsx b/frontend/src/routes/workspace/ProjectsPage.test.tsx
new file mode 100644
index 0000000000..0b69b44c35
--- /dev/null
+++ b/frontend/src/routes/workspace/ProjectsPage.test.tsx
@@ -0,0 +1,107 @@
+import { render, waitFor } from "@testing-library/react";
+import { StrictMode, type ReactNode } from "react";
+import { describe, expect, test, vi } from "vitest";
+import { ProjectsPage } from "./ProjectsPage";
+
+const mocks = vi.hoisted(() => ({ fetchProjectList: vi.fn() }));
+vi.mock("@/stores/app", () => {
+ const state = {
+ isLoggedIn: () => true,
+ fetchProjectList: mocks.fetchProjectList,
+ };
+ return {
+ useAppStore: Object.assign(
+ (selector: (s: typeof state) => unknown) => selector(state),
+ { getState: () => state }
+ ),
+ };
+});
+vi.mock("react-i18next", () => ({
+ initReactI18next: { type: "3rdParty", init: () => {} },
+ useTranslation: () => ({ t: (key: string) => key }),
+}));
+vi.mock("@/app/router", () => ({
+ router: {},
+ useCurrentRoute: () => ({ query: {} }),
+}));
+vi.mock("@/app/router/NavigationScrollRestoration", () => ({
+ useListScrollRestorationLoadMore: () => {},
+ markListScrollRestorationEntry: () => {},
+}));
+vi.mock("@/components/AdvancedSearch", () => ({
+ AdvancedSearch: () => null,
+ getValueFromScopes: () => "ACTIVE",
+}));
+vi.mock("@/components/header/ProjectCreateDialog", () => ({
+ ProjectCreateDialog: () => null,
+}));
+vi.mock("@/components/PermissionGuard", () => ({
+ PermissionGuard: () => null,
+}));
+vi.mock("@/components/ProjectTable", () => ({
+ ProjectTable: ({ projectList }: { projectList: { name: string }[] }) => (
+ <div>{projectList.map((p) => p.name).join(",")}</div>
+ ),
+}));
+vi.mock("@/components/WorkspacePageLayout", () => {
+ const Container = ({ children }: { children: ReactNode }) => (
+ <div>{children}</div>
+ );
+ return {
+ WorkspacePageLayout: Container,
+ WorkspacePageContent: Container,
+ WorkspacePageFooter: Container,
+ WorkspacePageToolbar: Container,
+ };
+});
+vi.mock("@/hooks/usePagedData", () => ({ PagedTableFooter: () => null }));
+vi.mock("@/hooks/useSessionPageSize", () => ({
+ useSessionPageSize: () => [50, () => {}],
+ getPageSizeOptions: () => [50],
+}));
+vi.mock("@/hooks/useURLSearchParam", () => {
+ const params = { query: "", scopes: [] };
+ return {
+ legacyStateSearchParams: () => params,
+ createAdvancedSearchParser: () => () => params,
+ serializeAdvancedSearch: () => "",
+ useURLSearchParam: () => [params, () => {}],
+ };
+});
+vi.mock("@/lib/productIntro", () => ({
+ useProductIntro: () => {},
+ CREATE_PROJECT_PRODUCT_INTRO: "create",
+ CONNECT_DATABASE_PRODUCT_INTRO: "connect",
+ PRODUCT_INTRO_QUERY_KEY: "intro",
+}));
+vi.mock("@/utils", async (original) => ({
+ ...(await original<typeof import("@/utils")>()),
+ hasWorkspacePermissionV2: () => false,
+}));
+
+describe("ProjectsPage", () => {
+ test("restarts the canceled initial fetch during StrictMode replay", async () => {
+ const signals: AbortSignal[] = [];
+ mocks.fetchProjectList.mockImplementation(
+ async ({ signal }: { signal: AbortSignal }) => {
+ signals.push(signal);
+ await Promise.resolve();
+ signal.throwIfAborted();
+ return { projects: [{ name: "projects/visible" }], nextPageToken: "" };
+ }
+ );
+ const view = render(
+ <StrictMode>
+ <ProjectsPage />
+ </StrictMode>
+ );
+ await waitFor(() =>
+ expect(view.getByText("projects/visible")).toBeTruthy()
+ );
+ expect(signals).toHaveLength(2);
+ expect(signals[0].aborted).toBe(true);
+ expect(signals[1].aborted).toBe(false);
+ view.unmount();
+ expect(signals[1].aborted).toBe(true);
+ });
+});
diff --git a/frontend/src/routes/workspace/ProjectsPage.tsx b/frontend/src/routes/workspace/ProjectsPage.tsx
index 0beda16c52..9cd12238d9 100644
--- a/frontend/src/routes/workspace/ProjectsPage.tsx
+++ b/frontend/src/routes/workspace/ProjectsPage.tsx
@@ -361,7 +361,8 @@ export function ProjectsPage() {
if (!isLoggedIn) return;
abortRef.current?.abort();
- abortRef.current = new AbortController();
+ const controller = new AbortController();
+ abortRef.current = controller;
const currentFetchId = ++fetchIdRef.current;
if (isRefresh) {
@@ -373,6 +374,7 @@ export function ProjectsPage() {
try {
const token = isRefresh ? "" : nextPageTokenRef.current;
const result = await useAppStore.getState().fetchProjectList({
+ signal: controller.signal,
pageToken: token,
pageSize,
filter: {
@@ -385,7 +387,8 @@ export function ProjectsPage() {
cache: true,
});
- if (currentFetchId !== fetchIdRef.current) return;
+ if (controller.signal.aborted || currentFetchId !== fetchIdRef.current)
+ return;
if (isRefresh) {
setProjects(result.projects);
@@ -395,6 +398,7 @@ export function ProjectsPage() {
nextPageTokenRef.current = result.nextPageToken ?? "";
setHasMore(Boolean(result.nextPageToken));
} catch (e) {
+ if (controller.signal.aborted) return;
if (e instanceof Error && e.name === "AbortError") return;
console.error(e);
} finally {
@@ -415,7 +419,10 @@ export function ProjectsPage() {
prevDepsRef.current = depsKey;
fetchProjects(true);
- return () => abortRef.current?.abort();
+ return () => {
+ prevDepsRef.current = "";
+ abortRef.current?.abort();
+ };
}, [
searchText,
stateFilter,
diff --git a/frontend/src/stores/app/project.test.ts b/frontend/src/stores/app/project.test.ts
index 9f96695821..67e4518a29 100644
--- a/frontend/src/stores/app/project.test.ts
+++ b/frontend/src/stores/app/project.test.ts
@@ -1,6 +1,9 @@
// @vitest-environment node
-import { describe, expect, test } from "vitest";
-import { getListProjectFilter } from "./project";
+import { create } from "@bufbuild/protobuf";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { State } from "@/types/proto-es/v1/common_pb";
+import { ProjectSchema } from "@/types/proto-es/v1/project_service_pb";
+import { createProjectSlice, getListProjectFilter } from "./project";
const QUOTED = 'SELECT * FROM "users"';
const ESCAPED = 'SELECT * FROM \\"users\\"';
@@ -12,3 +15,221 @@ describe("getListProjectFilter", () => {
expect(filter).toContain(ESCAPED.toLowerCase());
});
});
+
+const mocks = vi.hoisted(() => ({
+ listProjects: vi.fn(),
+ searchProjects: vi.fn(),
+ hasWorkspacePermissionV2: vi.fn(() => false),
+}));
+
+vi.mock("@/api", () => ({
+ projectServiceClientConnect: {
+ listProjects: mocks.listProjects,
+ searchProjects: mocks.searchProjects,
+ },
+}));
+
+vi.mock("@/utils", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("@/utils")>()),
+ hasWorkspacePermissionV2: mocks.hasWorkspacePermissionV2,
+}));
+
+const createStore = () => {
+ const state: Record<string, unknown> = {};
+ const set = (updater: unknown) => {
+ Object.assign(
+ state,
+ typeof updater === "function" ? updater(state) : updater
+ );
+ };
+ Object.assign(
+ state,
+ createProjectSlice(set as never, (() => state) as never, {} as never)
+ );
+ return state as ReturnType<typeof createProjectSlice>;
+};
+
+const project = (id: string) =>
+ create(ProjectSchema, { name: `projects/${id}` });
+
+describe("fetchProjectList", () => {
+ beforeEach(() => {
+ vi.resetAllMocks();
+ mocks.hasWorkspacePermissionV2.mockReturnValue(false);
+ });
+
+ test("fills short and empty pages and resumes without losing projects", async () => {
+ const a = project("a");
+ const b = project("b");
+ const c = project("c");
+ const d = project("d");
+ mocks.searchProjects
+ .mockResolvedValueOnce({ projects: [a], nextPageToken: "scan-3" })
+ .mockResolvedValueOnce({ projects: [], nextPageToken: "scan-6" })
+ .mockResolvedValueOnce({ projects: [b, c, d], nextPageToken: "scan-9" })
+ .mockResolvedValueOnce({ projects: [project("e")], nextPageToken: "" });
+ const store = createStore();
+ const params = {
+ pageSize: 3,
+ filter: { state: State.ACTIVE, query: "app" },
+ orderBy: "title asc",
+ cache: true,
+ };
+ const first = await store.fetchProjectList(params);
+ expect(first).toEqual({ projects: [a, b, c, d], nextPageToken: "scan-9" });
+ expect(Object.values(store.projectsByName)).toEqual([a, b, c, d]);
+ expect(
+ mocks.searchProjects.mock.calls.map(([request]) => ({
+ pageSize: request.pageSize,
+ pageToken: request.pageToken,
+ }))
+ ).toEqual([
+ { pageSize: 3, pageToken: "" },
+ { pageSize: 3, pageToken: "scan-3" },
+ { pageSize: 3, pageToken: "scan-6" },
+ ]);
+ for (const [request] of mocks.searchProjects.mock.calls) {
+ expect(request).toMatchObject({
+ filter: getListProjectFilter(params.filter),
+ orderBy: "title asc",
+ showDeleted: false,
+ });
+ }
+ const second = await store.fetchProjectList({
+ ...params,
+ pageToken: first.nextPageToken,
+ });
+ expect(second).toEqual({ projects: [project("e")], nextPageToken: "" });
+ expect(mocks.searchProjects.mock.calls[3][0]).toMatchObject({
+ pageSize: 3,
+ pageToken: "scan-9",
+ });
+ });
+
+ test.each([undefined, 0, 5000])(
+ "uses the API page-size bounds for %s",
+ async (pageSize) => {
+ mocks.searchProjects.mockResolvedValue({
+ projects: [],
+ nextPageToken: "",
+ });
+ await createStore().fetchProjectList({ pageSize });
+ expect(mocks.searchProjects.mock.calls[0][0].pageSize).toBe(
+ pageSize === 5000 ? 1000 : 10
+ );
+ }
+ );
+
+ test("returns all accumulated rows when the last page is short", async () => {
+ mocks.searchProjects
+ .mockResolvedValueOnce({
+ projects: [project("a")],
+ nextPageToken: "next",
+ })
+ .mockResolvedValueOnce({ projects: [project("b")], nextPageToken: "" });
+ expect(await createStore().fetchProjectList({ pageSize: 3 })).toEqual({
+ projects: [project("a"), project("b")],
+ nextPageToken: "",
+ });
+ });
+
+ test("stops at exhaustion when no projects are visible", async () => {
+ mocks.searchProjects
+ .mockResolvedValueOnce({ projects: [], nextPageToken: "next" })
+ .mockResolvedValueOnce({ projects: [], nextPageToken: "" });
+ expect(await createStore().fetchProjectList({ pageSize: 2 })).toEqual({
+ projects: [],
+ nextPageToken: "",
+ });
+ expect(mocks.searchProjects).toHaveBeenCalledTimes(2);
+ });
+
+ test("keeps a full workspace list page to one request", async () => {
+ mocks.hasWorkspacePermissionV2.mockReturnValue(true);
+ mocks.listProjects.mockResolvedValue({
+ projects: [project("a"), project("b")],
+ nextPageToken: "next",
+ });
+ const store = createStore();
+ expect(await store.fetchProjectList({ pageSize: 2 })).toEqual({
+ projects: [project("a"), project("b")],
+ nextPageToken: "next",
+ });
+ expect(mocks.listProjects).toHaveBeenCalledTimes(1);
+ expect(mocks.searchProjects).not.toHaveBeenCalled();
+ expect(store.projectsByName).toEqual({});
+ });
+
+ test("does not start an already canceled fetch", async () => {
+ const controller = new AbortController();
+ controller.abort();
+ await expect(
+ createStore().fetchProjectList({ pageSize: 2, signal: controller.signal })
+ ).rejects.toMatchObject({ name: "AbortError" });
+ expect(mocks.searchProjects).not.toHaveBeenCalled();
+ });
+
+ test.each([false, true])(
+ "passes cancellation to the RPC and stops an in-flight fetch (canList=%s)",
+ async (canList) => {
+ mocks.hasWorkspacePermissionV2.mockReturnValue(canList);
+ const rpc = canList ? mocks.listProjects : mocks.searchProjects;
+ const controller = new AbortController();
+ rpc.mockImplementationOnce((_request, options) => {
+ expect(options.signal).toBe(controller.signal);
+ return new Promise((_resolve, reject) => {
+ options.signal.addEventListener(
+ "abort",
+ () => reject(options.signal.reason),
+ { once: true }
+ );
+ });
+ });
+ const store = createStore();
+ const pending = store.fetchProjectList({
+ pageSize: 2,
+ signal: controller.signal,
+ cache: true,
+ });
+ controller.abort();
+ await expect(pending).rejects.toMatchObject({ name: "AbortError" });
+ expect(rpc).toHaveBeenCalledTimes(1);
+ expect(store.projectsByName).toEqual({});
+ }
+ );
+
+ test.each(["next", ""])(
+ "discards a response that arrives after cancellation (token=%s)",
+ async (nextPageToken) => {
+ const controller = new AbortController();
+ mocks.searchProjects.mockImplementationOnce(async () => {
+ controller.abort();
+ return { projects: [project("a")], nextPageToken };
+ });
+ const store = createStore();
+ await expect(
+ store.fetchProjectList({
+ pageSize: 2,
+ signal: controller.signal,
+ cache: true,
+ })
+ ).rejects.toMatchObject({ name: "AbortError" });
+ expect(mocks.searchProjects).toHaveBeenCalledTimes(1);
+ expect(store.projectsByName).toEqual({});
+ }
+ );
+
+ test("propagates a refill failure without caching a partial page", async () => {
+ mocks.searchProjects
+ .mockResolvedValueOnce({
+ projects: [project("a")],
+ nextPageToken: "next",
+ })
+ .mockRejectedValueOnce(new Error("fetch failed"));
+ const store = createStore();
+ await expect(
+ store.fetchProjectList({ pageSize: 2, cache: true })
+ ).rejects.toThrow("fetch failed");
+ expect(store.projectsByName).toEqual({});
+ });
+});
diff --git a/frontend/src/stores/app/project.ts b/frontend/src/stores/app/project.ts
index 542ec63439..e77eb5f6d5 100644
--- a/frontend/src/stores/app/project.ts
+++ b/frontend/src/stores/app/project.ts
@@ -304,12 +304,20 @@ export const createProjectSlice: AppSliceCreator<ProjectSlice> = (set, get) => {
const showDeleted = params.filter?.state !== State.ACTIVE;
const canList = hasWorkspacePermissionV2("bb.projects.list");
let pageToken = params.pageToken;
- let result: { projects: Project[]; nextPageToken: string };
- // The API can return an empty page with a non-empty next token; keep
- // paging until we get rows or run out.
+ const pageSize = Math.min(
+ params.pageSize && params.pageSize > 0 ? params.pageSize : 10,
+ 1000
+ );
+ const result: { projects: Project[]; nextPageToken: string } = {
+ projects: [],
+ nextPageToken: "",
+ };
+ // SearchProjects filters permissions after pagination. Keep scan batches
+ // full-sized and retain overflow rows so the continuation skips nothing.
while (true) {
+ params.signal?.throwIfAborted();
const request = {
- pageSize: params.pageSize,
+ pageSize,
pageToken,
filter,
orderBy: params.orderBy,
@@ -319,6 +327,7 @@ export const createProjectSlice: AppSliceCreator<ProjectSlice> = (set, get) => {
? await projectServiceClientConnect.listProjects(
createProto(ListProjectsRequestSchema, request),
{
+ signal: params.signal,
contextValues: createContextValues().set(
silentContextKey,
params.silent ?? true
@@ -328,17 +337,17 @@ export const createProjectSlice: AppSliceCreator<ProjectSlice> = (set, get) => {
: await projectServiceClientConnect.searchProjects(
createProto(SearchProjectsRequestSchema, request),
{
+ signal: params.signal,
contextValues: createContextValues().set(
silentContextKey,
params.silent ?? true
),
}
);
- result = {
- projects: response.projects,
- nextPageToken: response.nextPageToken,
- };
- if (result.nextPageToken !== "" && result.projects.length === 0) {
+ params.signal?.throwIfAborted();
+ result.projects.push(...response.projects);
+ result.nextPageToken = response.nextPageToken;
+ if (result.nextPageToken !== "" && result.projects.length < pageSize) {
pageToken = result.nextPageToken;
continue;
}
diff --git a/frontend/src/stores/app/projectAccess.ts b/frontend/src/stores/app/projectAccess.ts
index c1b2461ce4..37d1f91055 100644
--- a/frontend/src/stores/app/projectAccess.ts
+++ b/frontend/src/stores/app/projectAccess.ts
@@ -25,6 +25,7 @@ type ProjectAccess = {
getProjectByName: (name: string) => Project;
batchGetOrFetchProjects: (names: string[]) => Promise<Project[]>;
fetchProjectList: (params: {
+ signal?: AbortSignal;
pageSize?: number;
pageToken?: string;
silent?: boolean;
diff --git a/frontend/src/stores/app/types.ts b/frontend/src/stores/app/types.ts
index 723161c23f..60efa5245b 100644
--- a/frontend/src/stores/app/types.ts
+++ b/frontend/src/stores/app/types.ts
@@ -421,6 +421,7 @@ export type ProjectSlice = {
nextPageToken?: string;
}>;
fetchProjectList: (params: {
+ signal?: AbortSignal;
pageSize?: number;
pageToken?: string;
silent?: boolean;
diff --git a/frontend/src/utils/expr.ts b/frontend/src/utils/expr.ts
index 10b991adf0..770ee1c1ab 100644
--- a/frontend/src/utils/expr.ts
+++ b/frontend/src/utils/expr.ts
@@ -22,6 +22,7 @@ type LabeledOption = { value: string; label: string };
export type OptionConfig = {
search?: (params: {
+ signal?: AbortSignal;
search: string;
pageToken: string;
pageSize: number;
@@ -85,6 +86,7 @@ export const getProjectIdOptionConfig = (): OptionConfig => {
},
search: async (params) => {
return fetchProjectList({
+ signal: params.signal,
pageSize: params.pageSize,
pageToken: params.pageToken,
filter: {