Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

fix(web): load managed profile fields before the settings pages render

tiran133feba0587804d
diff --git a/apps/web/src/hooks/queries/config/use-get-config.ts b/apps/web/src/hooks/queries/config/use-get-config.ts
index e694afcc2..77f64d9c6 100644
--- a/apps/web/src/hooks/queries/config/use-get-config.ts
+++ b/apps/web/src/hooks/queries/config/use-get-config.ts
@@ -1,11 +1,15 @@
-import { useQuery } from "@tanstack/react-query";
+import { queryOptions, useQuery } from "@tanstack/react-query";
import { getConfig } from "@/fetchers/config/get-config";
-function useGetConfig() {
- return useQuery({
+export function configQueryOptions() {
+ return queryOptions({
queryKey: ["config"],
queryFn: getConfig,
});
}
+function useGetConfig() {
+ return useQuery(configQueryOptions());
+}
+
export default useGetConfig;
diff --git a/apps/web/src/hooks/queries/user/prefetch-managed-profile-fields.test.tsx b/apps/web/src/hooks/queries/user/prefetch-managed-profile-fields.test.tsx
new file mode 100644
index 000000000..604aa82b1
--- /dev/null
+++ b/apps/web/src/hooks/queries/user/prefetch-managed-profile-fields.test.tsx
@@ -0,0 +1,140 @@
+import { onlineManager, QueryClientProvider } from "@tanstack/react-query";
+import { cleanup, renderHook } from "@testing-library/react";
+import type { PropsWithChildren } from "react";
+import {
+ afterEach,
+ beforeEach,
+ describe,
+ expect,
+ it,
+ vi,
+} from "vite-plus/test";
+import queryClient from "@/query-client";
+import { prefetchManagedProfileFields } from "./prefetch-managed-profile-fields";
+import useManagedProfileFields from "./use-managed-profile-fields";
+
+const m = vi.hoisted(() => ({
+ getConfig: vi.fn(),
+ getCurrentUser: vi.fn(),
+ captureException: vi.fn(),
+}));
+
+vi.mock("@sentry/react", () => ({ captureException: m.captureException }));
+vi.mock("@/components/providers/auth-provider/hooks/use-auth", () => ({
+ default: () => ({ user: { id: "user-1" } }),
+}));
+vi.mock("@/fetchers/config/get-config", () => ({ getConfig: m.getConfig }));
+vi.mock("@/fetchers/user/get-current-user", () => ({
+ default: m.getCurrentUser,
+}));
+
+const wrapper = ({ children }: PropsWithChildren) => (
+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+);
+
+function managedFieldsOnFirstRender() {
+ const renders: ReturnType<typeof useManagedProfileFields>[] = [];
+ renderHook(
+ () => {
+ const fields = useManagedProfileFields();
+ renders.push(fields);
+ return fields;
+ },
+ { wrapper },
+ );
+ return renders[0];
+}
+
+function instanceManages(fields: string[]) {
+ m.getConfig.mockResolvedValue({ customOAuthManagedProfileFields: fields });
+}
+
+describe("prefetchManagedProfileFields", () => {
+ afterEach(() => {
+ cleanup();
+ queryClient.clear();
+ onlineManager.setOnline(true);
+ });
+
+ beforeEach(() => {
+ m.getConfig.mockReset();
+ m.getCurrentUser.mockReset();
+ m.captureException.mockClear();
+ });
+
+ it("opens with the server's fields for people with a provider account", async () => {
+ instanceManages(["name", "locale"]);
+ m.getCurrentUser.mockResolvedValue({ managedProfileFields: ["name"] });
+
+ await prefetchManagedProfileFields(queryClient, "user-1");
+
+ expect(managedFieldsOnFirstRender()).toEqual(["name"]);
+ expect(m.getConfig).toHaveBeenCalledTimes(1);
+ expect(m.getCurrentUser).toHaveBeenCalledTimes(1);
+ });
+
+ it("opens unlocked for people without a provider account", async () => {
+ instanceManages(["name", "locale"]);
+ m.getCurrentUser.mockResolvedValue({ managedProfileFields: [] });
+
+ await prefetchManagedProfileFields(queryClient, "user-1");
+
+ expect(managedFieldsOnFirstRender()).toEqual([]);
+ expect(m.getCurrentUser).toHaveBeenCalledTimes(1);
+ });
+
+ it("asks nothing about the user when the instance manages no fields", async () => {
+ instanceManages([]);
+
+ await prefetchManagedProfileFields(queryClient, "user-1");
+
+ expect(managedFieldsOnFirstRender()).toEqual([]);
+ expect(m.getCurrentUser).not.toHaveBeenCalled();
+ });
+
+ it("rides out a single failed config request", async () => {
+ instanceManages(["name", "locale"]);
+ m.getConfig.mockRejectedValueOnce(new Error("Service Unavailable"));
+ m.getCurrentUser.mockResolvedValue({ managedProfileFields: ["name"] });
+
+ await prefetchManagedProfileFields(queryClient, "user-1");
+
+ expect(managedFieldsOnFirstRender()).toEqual(["name"]);
+ expect(m.getConfig).toHaveBeenCalledTimes(2);
+ expect(m.captureException).not.toHaveBeenCalled();
+ });
+
+ it("rides out a single failed user lookup", async () => {
+ instanceManages(["name", "locale"]);
+ m.getCurrentUser
+ .mockRejectedValueOnce(new Error("Service Unavailable"))
+ .mockResolvedValue({ managedProfileFields: ["name"] });
+
+ await prefetchManagedProfileFields(queryClient, "user-1");
+
+ expect(managedFieldsOnFirstRender()).toEqual(["name"]);
+ expect(m.getCurrentUser).toHaveBeenCalledTimes(2);
+ expect(m.captureException).not.toHaveBeenCalled();
+ });
+
+ it("lets the page open when the server keeps failing", async () => {
+ instanceManages(["name", "locale"]);
+ m.getCurrentUser.mockRejectedValue(new Error("Service Unavailable"));
+
+ await expect(
+ prefetchManagedProfileFields(queryClient, "user-1"),
+ ).resolves.toBeUndefined();
+ expect(m.getCurrentUser).toHaveBeenCalledTimes(3);
+ });
+
+ it("lets the page open while offline", async () => {
+ onlineManager.setOnline(false);
+ instanceManages(["name"]);
+ m.getCurrentUser.mockRejectedValue(new TypeError("Failed to fetch"));
+
+ await expect(
+ prefetchManagedProfileFields(queryClient, "user-1"),
+ ).resolves.toBeUndefined();
+ expect(m.getCurrentUser).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/apps/web/src/hooks/queries/user/prefetch-managed-profile-fields.ts b/apps/web/src/hooks/queries/user/prefetch-managed-profile-fields.ts
new file mode 100644
index 000000000..2d5f3e8a7
--- /dev/null
+++ b/apps/web/src/hooks/queries/user/prefetch-managed-profile-fields.ts
@@ -0,0 +1,28 @@
+import type { QueryClient } from "@tanstack/react-query";
+import { configQueryOptions } from "@/hooks/queries/config/use-get-config";
+import { currentUserQueryOptions } from "@/hooks/queries/user/use-managed-profile-fields";
+
+// Offline fails at once and retries stay short, so the page opens quickly.
+const LOADER_FETCH_OPTIONS = {
+ networkMode: "always",
+ retryDelay: 300,
+} as const;
+
+export async function prefetchManagedProfileFields(
+ queryClient: QueryClient,
+ userId: string | undefined,
+) {
+ try {
+ const config = await queryClient.ensureQueryData({
+ ...configQueryOptions(),
+ ...LOADER_FETCH_OPTIONS,
+ });
+ if (!userId || config.customOAuthManagedProfileFields.length === 0) return;
+ await queryClient.ensureQueryData({
+ ...currentUserQueryOptions(userId),
+ ...LOADER_FETCH_OPTIONS,
+ });
+ } catch {
+ // The page renders anyway, and its own queries retry when it mounts.
+ }
+}
diff --git a/apps/web/src/hooks/queries/user/use-managed-profile-fields.ts b/apps/web/src/hooks/queries/user/use-managed-profile-fields.ts
index 2e902cca9..b206b0f02 100644
--- a/apps/web/src/hooks/queries/user/use-managed-profile-fields.ts
+++ b/apps/web/src/hooks/queries/user/use-managed-profile-fields.ts
@@ -1,4 +1,4 @@
-import { useQuery } from "@tanstack/react-query";
+import { queryOptions, useQuery } from "@tanstack/react-query";
import useAuth from "@/components/providers/auth-provider/hooks/use-auth";
import type { GetConfigResponse } from "@/fetchers/config/get-config";
import getCurrentUser from "@/fetchers/user/get-current-user";
@@ -7,14 +7,20 @@ import useGetConfig from "@/hooks/queries/config/use-get-config";
export type ManagedProfileField =
GetConfigResponse["customOAuthManagedProfileFields"][number];
+export function currentUserQueryOptions(userId: string | undefined) {
+ return queryOptions({
+ queryKey: ["current-user", userId],
+ queryFn: getCurrentUser,
+ });
+}
+
function useManagedProfileFields(): readonly ManagedProfileField[] {
const { user } = useAuth();
const { data: config } = useGetConfig();
const configured = config?.customOAuthManagedProfileFields ?? [];
const enabled = Boolean(user?.id) && configured.length > 0;
const { data, isPending } = useQuery({
- queryKey: ["current-user", user?.id],
- queryFn: getCurrentUser,
+ ...currentUserQueryOptions(user?.id),
enabled,
});
diff --git a/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/information.tsx b/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/information.tsx
index bcfec9c86..f3c9576b4 100644
--- a/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/information.tsx
+++ b/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/information.tsx
@@ -1,8 +1,17 @@
import { createFileRoute } from "@tanstack/react-router";
import { ProfilePage } from "@/components/settings/profile/profile-page";
+import { prefetchManagedProfileFields } from "@/hooks/queries/user/prefetch-managed-profile-fields";
export const Route = createFileRoute(
"/_layout/_authenticated/dashboard/settings/account/information",
)({
+ loader: {
+ handler: ({ context }) =>
+ prefetchManagedProfileFields(
+ context.queryClient,
+ context.session?.user.id,
+ ),
+ staleReloadMode: "blocking",
+ },
component: ProfilePage,
});
diff --git a/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/managed-profile-fields.test.tsx b/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/managed-profile-fields.test.tsx
new file mode 100644
index 000000000..f50758193
--- /dev/null
+++ b/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/managed-profile-fields.test.tsx
@@ -0,0 +1,148 @@
+import { type QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import {
+ createMemoryHistory,
+ createRootRouteWithContext,
+ createRoute,
+ createRouter,
+ Outlet,
+ RouterProvider,
+} from "@tanstack/react-router";
+import { act, cleanup, render } from "@testing-library/react";
+import { useLayoutEffect } from "react";
+import {
+ afterEach,
+ beforeEach,
+ describe,
+ expect,
+ it,
+ vi,
+} from "vite-plus/test";
+import useManagedProfileFields from "@/hooks/queries/user/use-managed-profile-fields";
+import queryClient from "@/query-client";
+import { Route as information } from "./information";
+import { Route as preferences } from "./preferences";
+
+const m = vi.hoisted(() => ({
+ getConfig: vi.fn(),
+ getCurrentUser: vi.fn(),
+}));
+
+vi.mock("@/components/providers/auth-provider/hooks/use-auth", () => ({
+ default: () => ({ user: { id: "user-1" } }),
+}));
+vi.mock("@/fetchers/config/get-config", () => ({ getConfig: m.getConfig }));
+vi.mock("@/fetchers/user/get-current-user", () => ({
+ default: m.getCurrentUser,
+}));
+vi.mock("@/components/settings/profile/profile-page", () => ({
+ ProfilePage: () => null,
+}));
+vi.mock("@/components/settings/preferences/preferences-page", () => ({
+ PreferencesPage: () => null,
+}));
+
+type SettingsLoader = {
+ handler: (match: {
+ context: { queryClient: QueryClient; session: { user: { id: string } } };
+ }) => Promise<void>;
+};
+
+async function renderSettingsRoute(loader: SettingsLoader) {
+ const commits: unknown[] = [];
+ function Page() {
+ const fields = useManagedProfileFields();
+ useLayoutEffect(() => {
+ commits.push(fields);
+ });
+ return null;
+ }
+
+ const root = createRootRouteWithContext<{ queryClient: QueryClient }>()({
+ component: Outlet,
+ });
+ const authenticated = createRoute({
+ getParentRoute: () => root,
+ id: "authenticated",
+ beforeLoad: () => ({
+ session: { user: { id: "user-1" }, session: { id: "session-1" } },
+ }),
+ component: Outlet,
+ });
+ const page = createRoute({
+ getParentRoute: () => authenticated,
+ path: "/page",
+ loader,
+ component: Page,
+ });
+ const elsewhere = createRoute({
+ getParentRoute: () => authenticated,
+ path: "/elsewhere",
+ });
+ const router = createRouter({
+ routeTree: root.addChildren([authenticated.addChildren([page, elsewhere])]),
+ history: createMemoryHistory({ initialEntries: ["/elsewhere"] }),
+ context: { queryClient },
+ });
+
+ render(
+ <QueryClientProvider client={queryClient}>
+ <RouterProvider router={router} />
+ </QueryClientProvider>,
+ );
+ await act(() => router.load());
+ return { commits, router };
+}
+
+describe.each([
+ ["profile", information.options.loader],
+ ["preferences", preferences.options.loader],
+])("%s route", (_name, loader) => {
+ afterEach(() => {
+ cleanup();
+ queryClient.clear();
+ vi.unstubAllGlobals();
+ });
+
+ beforeEach(() => {
+ vi.stubGlobal("scrollTo", () => {});
+ m.getConfig.mockReset();
+ m.getCurrentUser.mockReset();
+ m.getConfig.mockResolvedValue({
+ customOAuthManagedProfileFields: ["name", "locale"],
+ });
+ m.getCurrentUser.mockResolvedValue({ managedProfileFields: ["name"] });
+ });
+
+ it("opens with the person's managed fields, also on a return visit", async () => {
+ const { commits, router } = await renderSettingsRoute(
+ loader as SettingsLoader,
+ );
+
+ await act(() => router.navigate({ to: "/page" }));
+ expect(commits[0]).toEqual(["name"]);
+
+ await act(() => router.navigate({ to: "/elsewhere" }));
+ queryClient.removeQueries({ queryKey: ["current-user"] });
+ commits.length = 0;
+
+ let answer = () => {};
+ m.getCurrentUser.mockReturnValueOnce(
+ new Promise((resolve) => {
+ answer = () => resolve({ managedProfileFields: ["name"] });
+ }),
+ );
+ let returnVisit = Promise.resolve();
+ // Commit whatever the router renders before the server answers.
+ await act(async () => {
+ returnVisit = router.navigate({ to: "/page" });
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ });
+ await act(async () => {
+ answer();
+ await returnVisit;
+ });
+
+ expect(commits[0]).toEqual(["name"]);
+ expect(m.getCurrentUser).toHaveBeenCalledTimes(2);
+ });
+});
diff --git a/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/preferences.tsx b/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/preferences.tsx
index 36f0d495a..f8f00d54f 100644
--- a/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/preferences.tsx
+++ b/apps/web/src/routes/_layout/_authenticated/dashboard/settings/account/preferences.tsx
@@ -1,8 +1,17 @@
import { createFileRoute } from "@tanstack/react-router";
import { PreferencesPage } from "@/components/settings/preferences/preferences-page";
+import { prefetchManagedProfileFields } from "@/hooks/queries/user/prefetch-managed-profile-fields";
export const Route = createFileRoute(
"/_layout/_authenticated/dashboard/settings/account/preferences",
)({
+ loader: {
+ handler: ({ context }) =>
+ prefetchManagedProfileFields(
+ context.queryClient,
+ context.session?.user.id,
+ ),
+ staleReloadMode: "blocking",
+ },
component: PreferencesPage,
});