Skip to content

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

fix(frontend): stabilize React route permission guards (#20130)

boojack199d03dba65a
diff --git a/frontend/src/components/ProvideSQLEditorContext.vue b/frontend/src/components/ProvideSQLEditorContext.vue
index e2bee47cf2..7c7cee5da0 100644
--- a/frontend/src/components/ProvideSQLEditorContext.vue
+++ b/frontend/src/components/ProvideSQLEditorContext.vue
@@ -17,15 +17,13 @@
page="RoutePermissionGuardShell"
:page-props="{
project,
+ routeKey: route.fullPath,
className: 'm-6',
targetClassName: 'h-full min-h-0 flex flex-col',
onReady: handlePermissionReady,
}"
/>
- <teleport
- v-if="routePermitted && routePermissionTarget"
- :to="routePermissionTarget"
- >
+ <teleport v-if="routePermissionTarget" :to="routePermissionTarget">
<ProvideAIContext>
<router-view />
</ProvideAIContext>
@@ -46,7 +44,6 @@ import { useRoute, useRouter } from "vue-router";
import { BBSpin } from "@/bbkit";
import { useEmitteryEventListener } from "@/composables/useEmitteryEventListener";
import { useRouteChangeGuard } from "@/composables/useRouteChangeGuard";
-import { useRoutePermitted } from "@/composables/useRoutePermitted";
import { ProvideAIContext } from "@/plugins/ai";
import ReactPageMount from "@/react/ReactPageMount.vue";
import {
@@ -169,7 +166,14 @@ const project = computed(() => {
}
return proj;
});
-const routePermitted = useRoutePermitted(project);
+
+watch(
+ () => route.fullPath,
+ () => {
+ routePermissionTarget.value = null;
+ },
+ { flush: "sync" }
+);
const switchWorksheet = async (sheetName: string) => {
const openedSheetTab = tabStore.getTabByWorksheet(sheetName);
diff --git a/frontend/src/composables/useRoutePermitted.ts b/frontend/src/composables/useRoutePermitted.ts
deleted file mode 100644
index a118f728fb..0000000000
--- a/frontend/src/composables/useRoutePermitted.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import {
- type ComputedRef,
- computed,
- type MaybeRefOrGetter,
- toValue,
-} from "vue";
-import { useRoute } from "vue-router";
-import { usePermissionStore } from "@/store";
-import { BASIC_WORKSPACE_PERMISSIONS, type Permission } from "@/types";
-import type { Project } from "@/types/proto-es/v1/project_service_pb";
-
-// Mirrors useComponentPermissionState in the React shell. Runs in Vue
-// reactive context so the parent layout can gate `<router-view>` mount
-// synchronously on route change — otherwise an unauthorized route's
-// component can mount and fire setup-time requests in the window between
-// the route change and the React shell's async onReady(null).
-export function useRoutePermitted(
- project?: MaybeRefOrGetter<Project | undefined>
-): ComputedRef<boolean> {
- const route = useRoute();
- const permissionStore = usePermissionStore();
-
- return computed(() => {
- const workspacePermissions = permissionStore.currentPermissions;
- if (
- !BASIC_WORKSPACE_PERMISSIONS.every((p) => workspacePermissions.has(p))
- ) {
- return false;
- }
-
- const required = route.matched.flatMap(
- (record) => (record.meta.requiredPermissionList?.() ?? []) as Permission[]
- );
- if (required.length === 0) {
- return true;
- }
-
- const resolvedProject = project ? toValue(project) : undefined;
- const projectPermissions = resolvedProject
- ? permissionStore.currentPermissionsInProjectV1(resolvedProject)
- : null;
- return required.every(
- (p) => workspacePermissions.has(p) || !!projectPermissions?.has(p)
- );
- });
-}
diff --git a/frontend/src/layouts/BodyLayout.vue b/frontend/src/layouts/BodyLayout.vue
index eb3ab6262e..5d5e8915f1 100644
--- a/frontend/src/layouts/BodyLayout.vue
+++ b/frontend/src/layouts/BodyLayout.vue
@@ -30,7 +30,7 @@
</teleport>
<teleport
- v-if="!isProjectRoute && routePermitted && routePermissionTarget"
+ v-if="!isProjectRoute && routePermissionTarget"
:to="routePermissionTarget"
>
<router-view name="content" />
@@ -50,12 +50,11 @@
<script lang="ts" setup>
import { useWindowSize } from "@vueuse/core";
-import { computed, onMounted, onUnmounted, ref, shallowRef } from "vue";
+import { computed, onMounted, onUnmounted, ref, shallowRef, watch } from "vue";
import { useRoute, useRouter } from "vue-router";
import AgentWindowMount from "@/components/AgentWindowMount.vue";
import Quickstart from "@/components/Quickstart.vue";
import ReleaseRemindModal from "@/components/ReleaseRemindModal.vue";
-import { useRoutePermitted } from "@/composables/useRoutePermitted";
import { t } from "@/plugins/i18n";
import type { DashboardShellTargets } from "@/react/dashboard-shell";
import ReactPageMount from "@/react/ReactPageMount.vue";
@@ -87,7 +86,6 @@ const shellTargets = shallowRef<DashboardShellTargets>({
const mainContainerRef = ref<HTMLDivElement>();
const showReleaseModal = ref(false);
const routePermissionTarget = shallowRef<HTMLDivElement | null>(null);
-const routePermitted = useRoutePermitted();
const isRootPath = computed(() => {
return router.currentRoute.value.name === WORKSPACE_ROOT_MODULE;
@@ -114,6 +112,14 @@ const handlePermissionReady = (target: HTMLDivElement | null) => {
routePermissionTarget.value = target;
};
+watch(
+ () => route.fullPath,
+ () => {
+ routePermissionTarget.value = null;
+ },
+ { flush: "sync" }
+);
+
actuatorStore.tryToRemindRelease().then((openRemindModal) => {
if (
subscriptionStore.currentPlan === PlanType.ENTERPRISE &&
diff --git a/frontend/src/layouts/layout-bridge.test.ts b/frontend/src/layouts/layout-bridge.test.ts
index 633d532f7b..64aebd93f5 100644
--- a/frontend/src/layouts/layout-bridge.test.ts
+++ b/frontend/src/layouts/layout-bridge.test.ts
@@ -340,6 +340,11 @@ describe("layout bridges", () => {
'[data-testid="shell-content"] [data-testid="content-view"]'
)?.textContent
).toContain("connected");
+ expect(
+ document.querySelector(
+ '[data-testid="shell-quickstart"] [data-testid="quickstart"]'
+ )
+ ).not.toBeNull();
wrapper.unmount();
});
diff --git a/frontend/src/react/ReactRouteShellBridge.vue b/frontend/src/react/ReactRouteShellBridge.vue
index 8c85258000..21e33dfdc5 100644
--- a/frontend/src/react/ReactRouteShellBridge.vue
+++ b/frontend/src/react/ReactRouteShellBridge.vue
@@ -16,11 +16,16 @@
/>
<router-view v-else v-bind="targets.routeProps ?? {}" />
</teleport>
+
+ <teleport v-if="targets.quickstart" :to="targets.quickstart">
+ <Quickstart />
+ </teleport>
</template>
<script lang="ts" setup>
import { computed, shallowRef } from "vue";
import { useRoute } from "vue-router";
+import Quickstart from "@/components/Quickstart.vue";
import { provideBodyLayoutContext } from "@/layouts/common";
import type { ReactRouteShellTargets } from "@/react/dashboard-shell";
import ReactPageMount from "@/react/ReactPageMount.vue";
diff --git a/frontend/src/react/components/ComponentPermissionGuard.tsx b/frontend/src/react/components/ComponentPermissionGuard.tsx
index a26d950e16..501795b1b4 100644
--- a/frontend/src/react/components/ComponentPermissionGuard.tsx
+++ b/frontend/src/react/components/ComponentPermissionGuard.tsx
@@ -1,15 +1,24 @@
import { ShieldAlert, ShieldUser } from "lucide-react";
-import { lazy, type ReactNode, Suspense, useMemo, useState } from "react";
+import {
+ lazy,
+ type ReactNode,
+ Suspense,
+ useEffect,
+ useMemo,
+ useState,
+} from "react";
import { useTranslation } from "react-i18next";
import { FeatureBadge } from "@/react/components/FeatureBadge";
-import { PermissionGuard } from "@/react/components/PermissionGuard";
import { Button } from "@/react/components/ui/button";
-import { useVueState } from "@/react/hooks/useVueState";
import { REQUEST_ROLE_REQUIRED_PERMISSIONS } from "@/react/pages/settings/requestRoleButton";
-import { usePermissionStore, useSubscriptionV1Store } from "@/store";
-import { BASIC_WORKSPACE_PERMISSIONS, type Permission } from "@/types";
+import { useAppStore } from "@/react/stores/app";
+import { BASIC_WORKSPACE_PERMISSIONS, type Permission } from "@/types/iam";
+import { hasFeature as planHasFeature } from "@/types/plan";
import type { Project } from "@/types/proto-es/v1/project_service_pb";
-import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";
+import {
+ PlanFeature,
+ PlanType,
+} from "@/types/proto-es/v1/subscription_service_pb";
const RequestRoleSheet = lazy(async () => {
const module = await import("@/react/pages/settings/RequestRoleSheet");
@@ -33,6 +42,84 @@ interface ComponentPermissionState {
permitted: boolean;
}
+interface PermissionDeniedFallbackProps {
+ readonly missedBasicPermissions: Permission[];
+ readonly missedPermissions: Permission[];
+ readonly project?: Project;
+ readonly className?: string;
+ readonly path?: string;
+ readonly resources?: string[];
+ readonly enableRequestRole?: boolean;
+}
+
+export function usePermissionDataReady(project?: Project) {
+ const permissionKey = project?.name ?? "__workspace__";
+ const loadWorkspacePermissionState = useAppStore(
+ (state) => state.loadWorkspacePermissionState
+ );
+ const loadProjectIamPolicy = useAppStore(
+ (state) => state.loadProjectIamPolicy
+ );
+ const [readyKey, setReadyKey] = useState("");
+
+ useEffect(() => {
+ let stale = false;
+ setReadyKey("");
+
+ const requests: Promise<unknown>[] = [loadWorkspacePermissionState()];
+ if (project?.name) {
+ requests.push(loadProjectIamPolicy(project.name));
+ }
+
+ void Promise.all(requests).finally(() => {
+ if (!stale) {
+ setReadyKey(permissionKey);
+ }
+ });
+
+ return () => {
+ stale = true;
+ };
+ }, [loadProjectIamPolicy, loadWorkspacePermissionState, permissionKey]);
+
+ return readyKey === permissionKey;
+}
+
+function usePermissionAccess(project?: Project) {
+ const currentUserName = useAppStore((state) => state.currentUser?.name ?? "");
+ const roles = useAppStore((state) => state.roles);
+ const workspacePolicy = useAppStore((state) => state.workspacePolicy);
+ const projectPolicy = useAppStore((state) =>
+ project ? state.projectPoliciesByName[project.name] : undefined
+ );
+ const hasWorkspacePermission = useAppStore(
+ (state) => state.hasWorkspacePermission
+ );
+ const hasProjectPermission = useAppStore(
+ (state) => state.hasProjectPermission
+ );
+
+ return useMemo(
+ () => ({
+ hasRoutePermission: (permission: Permission) =>
+ project
+ ? hasProjectPermission(project, permission)
+ : hasWorkspacePermission(permission),
+ hasWorkspacePermission: (permission: Permission) =>
+ hasWorkspacePermission(permission),
+ }),
+ [
+ currentUserName,
+ hasProjectPermission,
+ hasWorkspacePermission,
+ project,
+ projectPolicy,
+ roles,
+ workspacePolicy,
+ ]
+ );
+}
+
export function useComponentPermissionState({
permissions,
project,
@@ -43,33 +130,17 @@ export function useComponentPermissionState({
"permissions" | "project" | "checkBasicWorkspacePermissions"
>
>): ComponentPermissionState {
- const permissionStore = usePermissionStore();
- const workspacePermissionKey = useVueState(() =>
- [...permissionStore.currentPermissions].sort().join("\n")
- );
- const projectPermissionKey = useVueState(() =>
- project
- ? [...permissionStore.currentPermissionsInProjectV1(project)]
- .sort()
- .join("\n")
- : ""
- );
+ const permissionAccess = usePermissionAccess(project);
return useMemo(() => {
- const workspacePermissions = new Set(
- workspacePermissionKey.split("\n").filter(Boolean) as Permission[]
- );
- const projectPermissions = new Set(
- projectPermissionKey.split("\n").filter(Boolean) as Permission[]
- );
const missedBasicPermissions = checkBasicWorkspacePermissions
- ? BASIC_WORKSPACE_PERMISSIONS.filter((p) => !workspacePermissions.has(p))
+ ? BASIC_WORKSPACE_PERMISSIONS.filter(
+ (p) => !permissionAccess.hasWorkspacePermission(p)
+ )
: [];
- const missedPermissions = permissions.filter((p) =>
- project
- ? !workspacePermissions.has(p) && !projectPermissions.has(p)
- : !workspacePermissions.has(p)
+ const missedPermissions = permissions.filter(
+ (p) => !permissionAccess.hasRoutePermission(p)
);
return {
@@ -78,48 +149,42 @@ export function useComponentPermissionState({
permitted:
missedBasicPermissions.length === 0 && missedPermissions.length === 0,
};
- }, [
- checkBasicWorkspacePermissions,
- permissions,
- project,
- projectPermissionKey,
- workspacePermissionKey,
- ]);
+ }, [checkBasicWorkspacePermissions, permissionAccess, permissions]);
}
-/**
- * ComponentPermissionGuard gates an entire component behind a permission check.
- *
- * - If the user has all required permissions, children are rendered normally.
- * - If the user is missing permissions, an error alert is shown listing the
- * missing permissions — matching the Vue `ComponentPermissionGuard` behavior.
- */
-export function ComponentPermissionGuard({
- permissions,
+export function PermissionDeniedFallback({
+ missedBasicPermissions,
+ missedPermissions,
project,
- children,
className,
path,
resources = [],
- checkBasicWorkspacePermissions = false,
enableRequestRole = false,
-}: ComponentPermissionGuardProps) {
+}: PermissionDeniedFallbackProps) {
const { t } = useTranslation();
const [showRequestRoleSheet, setShowRequestRoleSheet] = useState(false);
- const subscriptionStore = useSubscriptionV1Store();
- const hasRequestRoleFeature = useVueState(() =>
- subscriptionStore.hasFeature(PlanFeature.FEATURE_REQUEST_ROLE_WORKFLOW)
+ const loadSubscription = useAppStore((state) => state.loadSubscription);
+ const subscriptionPlan = useAppStore(
+ (state) => state.subscription?.plan ?? PlanType.FREE
+ );
+ const hasRequestRoleFeature = planHasFeature(
+ subscriptionPlan,
+ PlanFeature.FEATURE_REQUEST_ROLE_WORKFLOW
+ );
+ const requestRolePermissionAccess = usePermissionAccess(project);
+ const canRequestRole = useMemo(
+ () =>
+ REQUEST_ROLE_REQUIRED_PERMISSIONS.every((permission) =>
+ requestRolePermissionAccess.hasRoutePermission(permission)
+ ),
+ [requestRolePermissionAccess]
);
- const { missedBasicPermissions, missedPermissions, permitted } =
- useComponentPermissionState({
- permissions,
- project,
- checkBasicWorkspacePermissions,
- });
- if (permitted) {
- return <>{children}</>;
- }
+ useEffect(() => {
+ if (enableRequestRole) {
+ void loadSubscription();
+ }
+ }, [enableRequestRole, loadSubscription]);
const missed =
missedBasicPermissions.length > 0
@@ -165,29 +230,22 @@ export function ComponentPermissionGuard({
)}
{showRequestRole && (
<div>
- <PermissionGuard
- permissions={[...REQUEST_ROLE_REQUIRED_PERMISSIONS]}
- project={project}
+ <Button
+ variant="outline"
+ size="sm"
+ disabled={!canRequestRole || !hasRequestRoleFeature}
+ onClick={() => setShowRequestRoleSheet(true)}
>
- {({ disabled }) => (
- <Button
- variant="outline"
- size="sm"
- disabled={disabled || !hasRequestRoleFeature}
- onClick={() => setShowRequestRoleSheet(true)}
- >
- {hasRequestRoleFeature ? (
- <ShieldUser className="size-4" />
- ) : (
- <FeatureBadge
- feature={PlanFeature.FEATURE_REQUEST_ROLE_WORKFLOW}
- clickable={false}
- />
- )}
- {t("issue.title.request-role")}
- </Button>
+ {hasRequestRoleFeature ? (
+ <ShieldUser className="size-4" />
+ ) : (
+ <FeatureBadge
+ feature={PlanFeature.FEATURE_REQUEST_ROLE_WORKFLOW}
+ clickable={false}
+ />
)}
- </PermissionGuard>
+ {t("issue.title.request-role")}
+ </Button>
</div>
)}
</div>
@@ -205,3 +263,49 @@ export function ComponentPermissionGuard({
</div>
);
}
+
+/**
+ * ComponentPermissionGuard gates an entire component behind a permission check.
+ *
+ * - If the user has all required permissions, children are rendered normally.
+ * - If the user is missing permissions, an error alert is shown listing the
+ * missing permissions — matching the Vue `ComponentPermissionGuard` behavior.
+ */
+export function ComponentPermissionGuard({
+ permissions,
+ project,
+ children,
+ className,
+ path,
+ resources = [],
+ checkBasicWorkspacePermissions = false,
+ enableRequestRole = false,
+}: ComponentPermissionGuardProps) {
+ const permissionReady = usePermissionDataReady(project);
+ const { missedBasicPermissions, missedPermissions, permitted } =
+ useComponentPermissionState({
+ permissions,
+ project,
+ checkBasicWorkspacePermissions,
+ });
+
+ if (!permissionReady) {
+ return <div className={className} />;
+ }
+
+ if (permitted) {
+ return <>{children}</>;
+ }
+
+ return (
+ <PermissionDeniedFallback
+ missedBasicPermissions={missedBasicPermissions}
+ missedPermissions={missedPermissions}
+ project={project}
+ className={className}
+ path={path}
+ resources={resources}
+ enableRequestRole={enableRequestRole}
+ />
+ );
+}
diff --git a/frontend/src/react/components/ProjectRouteShell.tsx b/frontend/src/react/components/ProjectRouteShell.tsx
index 8c5911bac2..97f8c42ee2 100644
--- a/frontend/src/react/components/ProjectRouteShell.tsx
+++ b/frontend/src/react/components/ProjectRouteShell.tsx
@@ -32,6 +32,8 @@ export function ProjectRouteShell({
const navigate = useNavigate();
const navigateRef = useRef(navigate);
navigateRef.current = navigate;
+ const onReadyRef = useRef(onReady);
+ onReadyRef.current = onReady;
const notify = useNotify();
const projectName = projectResourceNameFromId(projectId);
const project = useAppStore((state) => state.projectsByName[projectName]);
@@ -52,12 +54,12 @@ export function ProjectRouteShell({
);
const setRecentProject = useAppStore((state) => state.setRecentProject);
const removeRecentVisit = useAppStore((state) => state.removeRecentVisit);
- const [ready, setReady] = useState(false);
+ const [readyProjectName, setReadyProjectName] = useState("");
useEffect(() => {
let stale = false;
- setReady(false);
- onReady?.(null);
+ setReadyProjectName("");
+ onReadyRef.current?.(null);
const load = async () => {
await Promise.all([loadCurrentUser(), loadServerInfo()]);
@@ -84,14 +86,14 @@ export function ProjectRouteShell({
setRecentProject(nextProject.name);
await loadProjectIamPolicy(nextProject.name);
if (!stale) {
- setReady(true);
+ setReadyProjectName(projectName);
}
};
void load();
return () => {
stale = true;
- onReady?.(null);
+ onReadyRef.current?.(null);
};
}, [
fetchProject,
@@ -99,13 +101,14 @@ export function ProjectRouteShell({
loadProjectIamPolicy,
loadServerInfo,
notify,
- onReady,
projectId,
projectName,
removeRecentVisit,
setRecentProject,
]);
+ const ready = readyProjectName === projectName;
+
useEffect(() => {
if (!ready || !project) return;
if (route.title) {
diff --git a/frontend/src/react/components/RoutePermissionGuardShell.test.tsx b/frontend/src/react/components/RoutePermissionGuardShell.test.tsx
index 0e0c782470..ea2da3f3a2 100644
--- a/frontend/src/react/components/RoutePermissionGuardShell.test.tsx
+++ b/frontend/src/react/components/RoutePermissionGuardShell.test.tsx
@@ -18,78 +18,61 @@ const mocks = vi.hoisted(() => ({
},
workspacePermissions: new Set<Permission>(),
projectPermissions: new Set<Permission>(),
- hasFeature: vi.fn(() => true),
+ loadWorkspacePermissionState: vi.fn(async () => {}),
+ loadProjectIamPolicy: vi.fn(async (_project: string) => undefined),
+ loadSubscription: vi.fn(async () => undefined),
}));
vi.mock("@/react/router", () => ({
useCurrentRoute: () => mocks.route,
}));
-vi.mock("@/react/components/ComponentPermissionGuard", () => {
- const basicPermissions: Permission[] = [
- "bb.roles.list",
- "bb.workspaces.getIamPolicy",
- "bb.settings.getWorkspaceProfile",
- ];
- const getState = ({
- permissions,
- project,
- checkBasicWorkspacePermissions,
- }: {
- permissions: Permission[];
- project?: unknown;
- checkBasicWorkspacePermissions?: boolean;
- }) => {
- const missedBasicPermissions = checkBasicWorkspacePermissions
- ? basicPermissions.filter((p) => !mocks.workspacePermissions.has(p))
- : [];
- const missedPermissions = permissions.filter((p) =>
- project
- ? !mocks.workspacePermissions.has(p) && !mocks.projectPermissions.has(p)
- : !mocks.workspacePermissions.has(p)
- );
- return {
- missedBasicPermissions,
- missedPermissions,
- permitted:
- missedBasicPermissions.length === 0 && missedPermissions.length === 0,
- };
- };
- return {
- useComponentPermissionState: getState,
- ComponentPermissionGuard: ({
- permissions,
- project,
- checkBasicWorkspacePermissions,
- path,
- className,
- }: {
- permissions: Permission[];
- project?: unknown;
- checkBasicWorkspacePermissions?: boolean;
- path?: string;
- className?: string;
- }) => {
- const { missedBasicPermissions, missedPermissions } = getState({
- permissions,
- project,
- checkBasicWorkspacePermissions,
- });
- const missed =
- missedBasicPermissions.length > 0
- ? missedBasicPermissions
- : missedPermissions;
- return (
- <div role="alert" className={className}>
- <span>{path}</span>
- {missed.map((permission) => (
- <span key={permission}>{permission}</span>
- ))}
- </div>
- );
- },
- };
-});
+vi.mock("@/react/hooks/useVueState", () => ({
+ useVueState: (getter: () => unknown) => getter(),
+}));
+
+vi.mock("@/react/components/FeatureBadge", () => ({
+ FeatureBadge: () => <span data-testid="feature-badge" />,
+}));
+
+vi.mock("@/react/pages/settings/RequestRoleSheet", () => ({
+ RequestRoleSheet: () => <div data-testid="request-role-sheet" />,
+}));
+
+vi.mock("@/react/stores/app", () => ({
+ useAppStore: (
+ selector: (state: {
+ currentUser: { name: string };
+ roles: unknown[];
+ subscription: { plan: number };
+ workspacePolicy: undefined;
+ projectPoliciesByName: Record<string, unknown>;
+ hasWorkspacePermission: (permission: Permission) => boolean;
+ hasProjectPermission: (
+ _project: unknown,
+ permission: Permission
+ ) => boolean;
+ loadWorkspacePermissionState: () => Promise<void>;
+ loadProjectIamPolicy: (project: string) => Promise<undefined>;
+ loadSubscription: () => Promise<undefined>;
+ }) => unknown
+ ) =>
+ selector({
+ currentUser: { name: "users/[email protected]" },
+ roles: [],
+ subscription: { plan: 3 },
+ workspacePolicy: undefined,
+ projectPoliciesByName: {},
+ hasWorkspacePermission: (permission) =>
+ mocks.workspacePermissions.has(permission),
+ hasProjectPermission: (_project, permission) =>
+ mocks.workspacePermissions.has(permission) ||
+ mocks.projectPermissions.has(permission),
+ loadWorkspacePermissionState: mocks.loadWorkspacePermissionState,
+ loadProjectIamPolicy: mocks.loadProjectIamPolicy,
+ loadSubscription: mocks.loadSubscription,
+ }),
+}));
vi.mock("react-i18next", () => ({
useTranslation: () => ({ t: (key: string) => key }),
@@ -111,7 +94,12 @@ beforeEach(() => {
mocks.route.fullPath = "/settings";
mocks.workspacePermissions = new Set(BASIC_PERMISSIONS);
mocks.projectPermissions = new Set();
- mocks.hasFeature.mockReturnValue(true);
+ mocks.loadWorkspacePermissionState.mockReset();
+ mocks.loadWorkspacePermissionState.mockResolvedValue(undefined);
+ mocks.loadProjectIamPolicy.mockReset();
+ mocks.loadProjectIamPolicy.mockResolvedValue(undefined);
+ mocks.loadSubscription.mockReset();
+ mocks.loadSubscription.mockResolvedValue(undefined);
container = document.createElement("div");
document.body.appendChild(container);
root = createRoot(container);
@@ -131,9 +119,17 @@ const renderShell = async (
await act(async () => {
root.render(<RoutePermissionGuardShell onReady={onReady} {...props} />);
});
+ await act(async () => {
+ await Promise.resolve();
+ });
return onReady;
};
+const requestRoleButton = () =>
+ Array.from(container.querySelectorAll("button")).find((button) =>
+ button.textContent?.includes("issue.title.request-role")
+ );
+
describe("RoutePermissionGuardShell", () => {
test("exposes a content target when route permissions pass", async () => {
mocks.route.requiredPermissions = ["bb.settings.get"];
@@ -144,6 +140,21 @@ describe("RoutePermissionGuardShell", () => {
expect(onReady).toHaveBeenLastCalledWith(expect.any(HTMLDivElement));
expect(container.querySelector("[role='alert']")).toBeNull();
expect(container.firstElementChild?.className).toBe("h-full min-h-0");
+ expect(mocks.loadWorkspacePermissionState).toHaveBeenCalledTimes(1);
+ });
+
+ test("does not block allowed routes on subscription loading", async () => {
+ mocks.route.requiredPermissions = ["bb.settings.get"];
+ mocks.workspacePermissions.add("bb.settings.get");
+ mocks.loadSubscription.mockImplementation(
+ () => new Promise<undefined>(() => undefined)
+ );
+
+ const onReady = await renderShell({ targetClassName: "h-full min-h-0" });
+
+ expect(onReady).toHaveBeenLastCalledWith(expect.any(HTMLDivElement));
+ expect(container.querySelector("[role='alert']")).toBeNull();
+ expect(mocks.loadSubscription).not.toHaveBeenCalled();
});
test("withholds the content target and renders an alert when permissions fail", async () => {
@@ -154,6 +165,7 @@ describe("RoutePermissionGuardShell", () => {
expect(onReady).toHaveBeenLastCalledWith(null);
expect(container.querySelector("[role='alert']")).not.toBeNull();
expect(container.textContent).toContain("bb.settings.set");
+ expect(mocks.loadWorkspacePermissionState).toHaveBeenCalledTimes(1);
});
test("checks basic workspace permissions before route permissions", async () => {
@@ -174,18 +186,41 @@ describe("RoutePermissionGuardShell", () => {
await act(async () => {
root.render(<RoutePermissionGuardShell onReady={onReady} />);
});
- const initialCalls = onReady.mock.calls.length;
expect(onReady).toHaveBeenLastCalledWith(expect.any(HTMLDivElement));
mocks.route.fullPath = "/settings?next=foo";
await act(async () => {
root.render(<RoutePermissionGuardShell onReady={onReady} />);
});
+ await act(async () => {
+ await Promise.resolve();
+ });
- expect(onReady).toHaveBeenCalledTimes(initialCalls + 1);
expect(onReady).toHaveBeenLastCalledWith(expect.any(HTMLDivElement));
});
+ test("does not reload permissions when onReady callback identity changes", async () => {
+ mocks.route.requiredPermissions = ["bb.settings.get"];
+ mocks.workspacePermissions.add("bb.settings.get");
+
+ await act(async () => {
+ root.render(<RoutePermissionGuardShell onReady={vi.fn()} />);
+ });
+ await act(async () => {
+ await Promise.resolve();
+ });
+ expect(mocks.loadWorkspacePermissionState).toHaveBeenCalledTimes(1);
+
+ await act(async () => {
+ root.render(<RoutePermissionGuardShell onReady={vi.fn()} />);
+ });
+ await act(async () => {
+ await Promise.resolve();
+ });
+
+ expect(mocks.loadWorkspacePermissionState).toHaveBeenCalledTimes(1);
+ });
+
test("uses project permissions when a project is provided", async () => {
mocks.route.requiredPermissions = ["bb.databases.get"];
mocks.projectPermissions = new Set(["bb.databases.get"]);
@@ -199,5 +234,70 @@ describe("RoutePermissionGuardShell", () => {
expect(onReady).toHaveBeenLastCalledWith(expect.any(HTMLDivElement));
expect(container.querySelector("[role='alert']")).toBeNull();
+ expect(mocks.loadProjectIamPolicy).toHaveBeenCalledWith("projects/prod");
+ });
+
+ test("clears the content target while a new project policy is loading", async () => {
+ mocks.route.requiredPermissions = ["bb.databases.get"];
+ mocks.projectPermissions = new Set(["bb.databases.get"]);
+
+ const onReady = await renderShell({
+ project: {
+ name: "projects/prod",
+ allowRequestRole: true,
+ } as never,
+ });
+ expect(onReady).toHaveBeenLastCalledWith(expect.any(HTMLDivElement));
+
+ mocks.loadProjectIamPolicy.mockImplementation((project) =>
+ project === "projects/next"
+ ? new Promise<undefined>(() => undefined)
+ : Promise.resolve(undefined)
+ );
+
+ await act(async () => {
+ root.render(
+ <RoutePermissionGuardShell
+ onReady={onReady}
+ project={
+ {
+ name: "projects/next",
+ allowRequestRole: true,
+ } as never
+ }
+ />
+ );
+ });
+
+ expect(onReady).toHaveBeenLastCalledWith(null);
+ expect(container.querySelector("[role='alert']")).toBeNull();
+ });
+
+ test("enables request role CTA through React project permissions", async () => {
+ mocks.route.requiredPermissions = ["bb.databases.get"];
+ mocks.projectPermissions = new Set(["bb.issues.create"]);
+
+ await renderShell({
+ project: {
+ name: "projects/prod",
+ allowRequestRole: true,
+ } as never,
+ });
+
+ expect(requestRoleButton()?.disabled).toBe(false);
+ });
+
+ test("disables request role CTA when React project permissions are missing", async () => {
+ mocks.route.requiredPermissions = ["bb.databases.get"];
+ mocks.projectPermissions = new Set();
+
+ await renderShell({
+ project: {
+ name: "projects/prod",
+ allowRequestRole: true,
+ } as never,
+ });
+
+ expect(requestRoleButton()?.disabled).toBe(true);
});
});
diff --git a/frontend/src/react/components/RoutePermissionGuardShell.tsx b/frontend/src/react/components/RoutePermissionGuardShell.tsx
index 54aeef0492..828142eb7a 100644
--- a/frontend/src/react/components/RoutePermissionGuardShell.tsx
+++ b/frontend/src/react/components/RoutePermissionGuardShell.tsx
@@ -1,7 +1,8 @@
import { useEffect, useRef } from "react";
import {
- ComponentPermissionGuard,
+ PermissionDeniedFallback,
useComponentPermissionState,
+ usePermissionDataReady,
} from "@/react/components/ComponentPermissionGuard";
import { useCurrentRoute } from "@/react/router";
import type { Project } from "@/types/proto-es/v1/project_service_pb";
@@ -23,33 +24,49 @@ export function RoutePermissionGuardShell({
}: RoutePermissionGuardShellProps) {
const route = useCurrentRoute();
const targetRef = useRef<HTMLDivElement>(null);
+ const onReadyRef = useRef(onReady);
const permissions = route.requiredPermissions;
- const { permitted } = useComponentPermissionState({
- permissions,
- project,
- checkBasicWorkspacePermissions: true,
- });
+ const permissionReady = usePermissionDataReady(project);
+ const { missedBasicPermissions, missedPermissions, permitted } =
+ useComponentPermissionState({
+ permissions,
+ project,
+ checkBasicWorkspacePermissions: true,
+ });
useEffect(() => {
- onReady?.(permitted ? targetRef.current : null);
- }, [onReady, permitted, project?.name, route.fullPath, routeKey]);
+ onReadyRef.current = onReady;
+ }, [onReady]);
useEffect(() => {
- return () => onReady?.(null);
- }, [onReady]);
+ onReadyRef.current?.(null);
+ return () => {
+ onReadyRef.current?.(null);
+ };
+ }, [project?.name, route.fullPath, routeKey]);
+
+ useEffect(() => {
+ if (!permissionReady) {
+ onReadyRef.current?.(null);
+ return;
+ }
+ onReadyRef.current?.(permitted ? targetRef.current : null);
+ }, [permissionReady, permitted, project?.name, route.fullPath, routeKey]);
+
+ if (!permissionReady) {
+ return <div className={targetClassName} />;
+ }
if (!permitted) {
return (
- <ComponentPermissionGuard
- permissions={permissions}
+ <PermissionDeniedFallback
+ missedBasicPermissions={missedBasicPermissions}
+ missedPermissions={missedPermissions}
project={project}
className={className}
path={route.fullPath}
- checkBasicWorkspacePermissions
enableRequestRole
- >
- <div />
- </ComponentPermissionGuard>
+ />
);
}
diff --git a/frontend/src/react/no-legacy-vue-deps.test.ts b/frontend/src/react/no-legacy-vue-deps.test.ts
index 1e1172edfe..0aa4f6c0c2 100644
--- a/frontend/src/react/no-legacy-vue-deps.test.ts
+++ b/frontend/src/react/no-legacy-vue-deps.test.ts
@@ -16,6 +16,7 @@ const sources = import.meta.glob(
"./components/InstanceRouteShell.tsx",
"./components/IssuesRouteShell.tsx",
"./components/RoutePermissionGuardShell.tsx",
+ "./components/ComponentPermissionGuard.tsx",
],
{
query: "?raw",
@@ -76,4 +77,41 @@ describe("React Project and Settings legacy Vue dependencies", () => {
}
expect(violations).toEqual([]);
});
+
+ test("route permission guard reads React permission state", () => {
+ const violations: string[] = [];
+ for (const [file, source] of Object.entries(sources)) {
+ if (!file.endsWith("/ComponentPermissionGuard.tsx")) {
+ continue;
+ }
+ for (const bannedImport of [
+ "usePermissionStore",
+ "@/react/components/PermissionGuard",
+ ]) {
+ if (source.includes(bannedImport)) {
+ violations.push(`${file}: ${bannedImport}`);
+ }
+ }
+ }
+ expect(violations).toEqual([]);
+ });
+
+ test("ProjectRouteShell does not preload unrelated permission state", () => {
+ const violations: string[] = [];
+ for (const [file, source] of Object.entries(sources)) {
+ if (!file.endsWith("/ProjectRouteShell.tsx")) {
+ continue;
+ }
+ for (const bannedImport of [
+ "@/store",
+ "useProjectIamPolicyStore",
+ "loadSubscription",
+ ]) {
+ if (source.includes(bannedImport)) {
+ violations.push(`${file}: ${bannedImport}`);
+ }
+ }
+ }
+ expect(violations).toEqual([]);
+ });
});
diff --git a/frontend/src/react/pages/project/ProjectLandingPage.test.tsx b/frontend/src/react/pages/project/ProjectLandingPage.test.tsx
new file mode 100644
index 0000000000..c642ab57f4
--- /dev/null
+++ b/frontend/src/react/pages/project/ProjectLandingPage.test.tsx
@@ -0,0 +1,53 @@
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+
+(
+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+const mocks = vi.hoisted(() => ({
+ replace: vi.fn(),
+}));
+
+vi.mock("@/router", () => ({
+ router: {
+ replace: mocks.replace,
+ },
+}));
+
+vi.mock("@/router/dashboard/projectV1", () => ({
+ PROJECT_V1_ROUTE_ISSUES: "project.issues",
+}));
+
+import { ProjectLandingPage } from "./ProjectLandingPage";
+
+let container: HTMLDivElement;
+let root: ReturnType<typeof createRoot>;
+
+beforeEach(() => {
+ mocks.replace.mockClear();
+ container = document.createElement("div");
+ document.body.appendChild(container);
+ root = createRoot(container);
+});
+
+afterEach(() => {
+ act(() => {
+ root.unmount();
+ });
+ document.body.removeChild(container);
+});
+
+describe("ProjectLandingPage", () => {
+ test("redirects project landing to issues", async () => {
+ await act(async () => {
+ root.render(<ProjectLandingPage projectId="prod" />);
+ });
+
+ expect(mocks.replace).toHaveBeenCalledWith({
+ name: "project.issues",
+ params: { projectId: "prod" },
+ });
+ });
+});
diff --git a/frontend/src/react/pages/project/ProjectLandingPage.tsx b/frontend/src/react/pages/project/ProjectLandingPage.tsx
index ecacea385f..232c4daf07 100644
--- a/frontend/src/react/pages/project/ProjectLandingPage.tsx
+++ b/frontend/src/react/pages/project/ProjectLandingPage.tsx
@@ -1,31 +1,14 @@
import { useEffect } from "react";
import { router } from "@/router";
-import {
- PROJECT_V1_ROUTE_DATABASES,
- PROJECT_V1_ROUTE_ISSUES,
-} from "@/router/dashboard/projectV1";
-import { useProjectV1Store } from "@/store";
-import { projectNamePrefix } from "@/store/modules/v1/common";
-import { hasProjectPermissionV2 } from "@/utils";
+import { PROJECT_V1_ROUTE_ISSUES } from "@/router/dashboard/projectV1";
export function ProjectLandingPage({ projectId }: { projectId: string }) {
- const projectName = `${projectNamePrefix}${projectId}`;
-
useEffect(() => {
- const projectStore = useProjectV1Store();
- let cancelled = false;
- projectStore.getOrFetchProjectByName(projectName).then((project) => {
- if (cancelled) return;
- if (hasProjectPermissionV2(project, "bb.issues.list")) {
- router.replace({ name: PROJECT_V1_ROUTE_ISSUES });
- } else {
- router.replace({ name: PROJECT_V1_ROUTE_DATABASES });
- }
+ router.replace({
+ name: PROJECT_V1_ROUTE_ISSUES,
+ params: { projectId },
});
- return () => {
- cancelled = true;
- };
- }, [projectName]);
+ }, [projectId]);
return <div />;
}
diff --git a/frontend/src/react/pages/settings/ProjectsPage.navigation.test.ts b/frontend/src/react/pages/settings/ProjectsPage.navigation.test.ts
new file mode 100644
index 0000000000..7b94266abc
--- /dev/null
+++ b/frontend/src/react/pages/settings/ProjectsPage.navigation.test.ts
@@ -0,0 +1,12 @@
+import { describe, expect, test } from "vitest";
+
+import source from "./ProjectsPage.tsx?raw";
+
+describe("ProjectsPage navigation", () => {
+ test("opens projects from the table on the issues page", () => {
+ expect(source).toContain("PROJECT_V1_ROUTE_ISSUES");
+ expect(source).toContain("projectIssuesRoute(project)");
+ expect(source).not.toContain("PROJECT_V1_ROUTE_DETAIL");
+ expect(source).not.toContain("router.push({ path: `/${project.name}` })");
+ });
+});
diff --git a/frontend/src/react/pages/settings/ProjectsPage.tsx b/frontend/src/react/pages/settings/ProjectsPage.tsx
index efd1bc0788..72c84bd72e 100644
--- a/frontend/src/react/pages/settings/ProjectsPage.tsx
+++ b/frontend/src/react/pages/settings/ProjectsPage.tsx
@@ -30,7 +30,7 @@ import {
} from "@/react/hooks/useSessionPageSize";
import { cn } from "@/react/lib/utils";
import { router } from "@/router";
-import { PROJECT_V1_ROUTE_DETAIL } from "@/router/dashboard/projectV1";
+import { PROJECT_V1_ROUTE_ISSUES } from "@/router/dashboard/projectV1";
import {
pushNotification,
useAuthStore,
@@ -46,6 +46,13 @@ import {
hasWorkspacePermissionV2,
} from "@/utils";
+export function projectIssuesRoute(project: Project) {
+ return {
+ name: PROJECT_V1_ROUTE_ISSUES,
+ params: { projectId: getProjectName(project.name) },
+ };
+}
+
// ============================================================
// ConfirmDialog
// ============================================================
@@ -675,19 +682,16 @@ export function ProjectsPage() {
const canDelete = hasWorkspacePermissionV2("bb.projects.delete");
const handleCreated = useCallback((project: Project) => {
- router.push({ path: `/${project.name}` });
+ router.push(projectIssuesRoute(project));
}, []);
const handleRowClick = useCallback(
(project: Project, e: React.MouseEvent) => {
- const route = router.resolve({
- name: PROJECT_V1_ROUTE_DETAIL,
- params: { projectId: getProjectName(project.name) },
- });
+ const route = router.resolve(projectIssuesRoute(project));
if (e.ctrlKey || e.metaKey) {
window.open(route.fullPath, "_blank");
} else {
- router.push(route);
+ router.push(projectIssuesRoute(project));
}
},
[]