Skip to content

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

refactor: delete instance

ecmadaoa8fbbf48a543
diff --git a/frontend/src/react/components/EnvironmentLabel.test.tsx b/frontend/src/react/components/EnvironmentLabel.test.tsx
new file mode 100644
index 0000000000..95372a01f5
--- /dev/null
+++ b/frontend/src/react/components/EnvironmentLabel.test.tsx
@@ -0,0 +1,81 @@
+import type { MouseEventHandler, ReactElement, ReactNode } from "react";
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import type { Environment } from "@/types";
+import { EnvironmentBadge } from "./EnvironmentLabel";
+
+(
+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+vi.mock("react-i18next", () => ({
+ initReactI18next: { type: "3rdParty", init: () => {} },
+ useTranslation: () => ({ t: (key: string) => key }),
+}));
+
+vi.mock("@/react/components/RouterLink", () => ({
+ RouterLink: ({
+ children,
+ className,
+ onClick,
+ to,
+ }: {
+ children: ReactNode;
+ className?: string;
+ onClick?: MouseEventHandler<HTMLAnchorElement>;
+ to: { path?: string };
+ }) => (
+ <a className={className} data-path={to.path} onClick={onClick}>
+ {children}
+ </a>
+ ),
+}));
+
+const render = async (element: ReactElement) => {
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+
+ await act(async () => {
+ root.render(element);
+ await Promise.resolve();
+ });
+
+ return { container, root };
+};
+
+const environment = {
+ id: "prod",
+ name: "environments/prod",
+ title: "Production",
+ color: "#16a34a",
+ order: 0,
+ tags: {},
+} as Environment;
+
+describe("EnvironmentBadge", () => {
+ let root: Root | undefined;
+
+ afterEach(() => {
+ act(() => root?.unmount());
+ document.body.innerHTML = "";
+ root = undefined;
+ });
+
+ test("wraps the badge with RouterLink when link is enabled", async () => {
+ const rendered = await render(
+ <EnvironmentBadge
+ environment={environment}
+ hasEnvTierFeature={false}
+ link
+ />
+ );
+ root = rendered.root;
+
+ const link = rendered.container.querySelector("a");
+ expect(link?.getAttribute("data-path")).toBe("/environments/prod");
+ expect(link?.className).toBe("hover:underline");
+ expect(link?.textContent).toBe("Production");
+ });
+});
diff --git a/frontend/src/react/components/EnvironmentLabel.tsx b/frontend/src/react/components/EnvironmentLabel.tsx
index 4c343ed1a3..3dd1ea5ab6 100644
--- a/frontend/src/react/components/EnvironmentLabel.tsx
+++ b/frontend/src/react/components/EnvironmentLabel.tsx
@@ -1,11 +1,13 @@
import { ShieldAlert } from "lucide-react";
import { memo } from "react";
import { useTranslation } from "react-i18next";
+import { RouterLink } from "@/react/components/RouterLink";
import { useEnvironment, usePlanFeature } from "@/react/hooks/useAppState";
import { cn } from "@/react/lib/utils";
import type { Environment } from "@/types";
import {
DEFAULT_ENVIRONMENT_COLOR,
+ formatEnvironmentName,
NULL_ENVIRONMENT_NAME,
UNKNOWN_ENVIRONMENT_NAME,
} from "@/types";
@@ -25,10 +27,12 @@ export const EnvironmentBadge = memo(function EnvironmentBadge({
environment,
hasEnvTierFeature,
className,
+ link,
}: {
environment: Environment;
hasEnvTierFeature: boolean;
className?: string;
+ link?: boolean;
}) {
const { t } = useTranslation();
@@ -41,7 +45,7 @@ export const EnvironmentBadge = memo(function EnvironmentBadge({
? null
: hexToRgb(environment.color || DEFAULT_ENVIRONMENT_COLOR);
- return (
+ const badge = (
<span
className={cn(
"inline-flex items-center gap-x-1 px-1.5 rounded-xs truncate",
@@ -70,6 +74,22 @@ export const EnvironmentBadge = memo(function EnvironmentBadge({
)}
</span>
);
+
+ if (!link || isUnset) {
+ return badge;
+ }
+
+ return (
+ <RouterLink
+ to={{ path: `/${formatEnvironmentName(environment.id)}` }}
+ className="hover:underline"
+ onClick={(e) => {
+ e.stopPropagation();
+ }}
+ >
+ {badge}
+ </RouterLink>
+ );
});
/**
@@ -87,10 +107,12 @@ export function EnvironmentLabel({
environment: envProp,
environmentName,
className,
+ link,
}: {
environment?: Environment;
environmentName?: string;
className?: string;
+ link?: boolean;
}) {
// Always called (rules of hooks); result ignored when envProp is provided.
const envFromStore = useEnvironment(environmentName || NULL_ENVIRONMENT_NAME);
@@ -103,6 +125,7 @@ export function EnvironmentLabel({
environment={environment}
hasEnvTierFeature={hasEnvTierFeature}
className={className}
+ link={link}
/>
);
}
diff --git a/frontend/src/react/components/ProjectLabel.test.tsx b/frontend/src/react/components/ProjectLabel.test.tsx
new file mode 100644
index 0000000000..f29e92e777
--- /dev/null
+++ b/frontend/src/react/components/ProjectLabel.test.tsx
@@ -0,0 +1,180 @@
+import type { MouseEventHandler, ReactElement, ReactNode } from "react";
+import { act } from "react";
+import { createRoot, type Root } 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(() => ({
+ useProjectByName: vi.fn(),
+ getOrFetchProjectByName: vi.fn(),
+ hasWorkspacePermissionV2: vi.fn(() => true),
+}));
+
+vi.mock("react-i18next", () => ({
+ initReactI18next: { type: "3rdParty", init: () => {} },
+ useTranslation: () => ({ t: (key: string) => key }),
+}));
+
+vi.mock("@/react/components/RouterLink", () => ({
+ RouterLink: ({
+ children,
+ className,
+ onClick,
+ to,
+ }: {
+ children: ReactNode;
+ className?: string;
+ onClick?: MouseEventHandler<HTMLAnchorElement>;
+ to: { name?: string; params?: Record<string, string> };
+ }) => (
+ <a
+ className={className}
+ data-route-name={to.name}
+ data-project-id={to.params?.projectId}
+ onClick={onClick}
+ >
+ {children}
+ </a>
+ ),
+}));
+
+vi.mock("@/react/hooks/useProjectByName", () => ({
+ useProjectByName: mocks.useProjectByName,
+}));
+
+vi.mock("@/react/stores/app", () => ({
+ useAppStore: {
+ getState: () => ({
+ getOrFetchProjectByName: mocks.getOrFetchProjectByName,
+ }),
+ },
+}));
+
+vi.mock("@/utils", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("@/utils")>()),
+ hasWorkspacePermissionV2: mocks.hasWorkspacePermissionV2,
+}));
+
+import { ProjectLabel } from "./ProjectLabel";
+
+const render = async (element: ReactElement) => {
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+
+ await act(async () => {
+ root.render(element);
+ await Promise.resolve();
+ });
+
+ return { container, root };
+};
+
+describe("ProjectLabel", () => {
+ let root: Root | undefined;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.hasWorkspacePermissionV2.mockReturnValue(true);
+ mocks.useProjectByName.mockReturnValue({
+ name: "projects/sample",
+ title: "Sample Project",
+ });
+ });
+
+ afterEach(() => {
+ act(() => root?.unmount());
+ document.body.innerHTML = "";
+ root = undefined;
+ });
+
+ test("renders the project title as a label", async () => {
+ const rendered = await render(<ProjectLabel projectName="projects/sample" />);
+ root = rendered.root;
+
+ expect(rendered.container.textContent).toBe("Sample Project");
+ expect(rendered.container.querySelector("a")).toBeNull();
+ expect(mocks.getOrFetchProjectByName).toHaveBeenCalledWith(
+ "projects/sample",
+ true
+ );
+ });
+
+ test("preserves className when rendering a label", async () => {
+ const rendered = await render(
+ <ProjectLabel projectName="projects/sample" className="project-label" />
+ );
+ root = rendered.root;
+
+ const label = rendered.container.querySelector(".project-label");
+ expect(label?.textContent).toBe("Sample Project");
+ expect(rendered.container.querySelector("a")).toBeNull();
+ });
+
+ test("renders the project title as a link", async () => {
+ const rendered = await render(
+ <ProjectLabel projectName="projects/sample" link />
+ );
+ root = rendered.root;
+
+ const link = rendered.container.querySelector("a");
+ expect(link?.textContent).toBe("Sample Project");
+ expect(link?.getAttribute("data-route-name")).toBe(
+ "workspace.project.detail"
+ );
+ expect(link?.getAttribute("data-project-id")).toBe("sample");
+ expect(mocks.getOrFetchProjectByName).toHaveBeenCalledWith(
+ "projects/sample",
+ true
+ );
+ });
+
+ test("stops linked label clicks from bubbling", async () => {
+ const onParentClick = vi.fn();
+ const onLabelClick = vi.fn();
+ const rendered = await render(
+ <div onClick={onParentClick}>
+ <ProjectLabel
+ projectName="projects/sample"
+ link
+ onClick={onLabelClick}
+ />
+ </div>
+ );
+ root = rendered.root;
+
+ const link = rendered.container.querySelector("a");
+ expect(link).not.toBeNull();
+ link?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true, cancelable: true })
+ );
+
+ expect(onLabelClick).toHaveBeenCalledTimes(1);
+ expect(onParentClick).not.toHaveBeenCalled();
+ });
+
+ test("falls back to the project id when the project is not cached", async () => {
+ mocks.useProjectByName.mockReturnValue({
+ name: "projects/UNKNOWN",
+ title: "",
+ });
+
+ const rendered = await render(<ProjectLabel projectName="projects/sample" />);
+ root = rendered.root;
+
+ expect(rendered.container.textContent).toBe("sample");
+ });
+
+ test("does not fetch the project when custom content is provided", async () => {
+ const rendered = await render(
+ <ProjectLabel projectName="projects/sample">Custom Project</ProjectLabel>
+ );
+ root = rendered.root;
+
+ expect(rendered.container.textContent).toBe("Custom Project");
+ expect(mocks.getOrFetchProjectByName).not.toHaveBeenCalled();
+ });
+});
diff --git a/frontend/src/react/components/ProjectLabel.tsx b/frontend/src/react/components/ProjectLabel.tsx
new file mode 100644
index 0000000000..29752b3153
--- /dev/null
+++ b/frontend/src/react/components/ProjectLabel.tsx
@@ -0,0 +1,91 @@
+import { type MouseEventHandler, type ReactNode, useEffect } from "react";
+import { useTranslation } from "react-i18next";
+import {
+ RouterLink,
+ type RouterLinkProps,
+} from "@/react/components/RouterLink";
+import { useProjectByName } from "@/react/hooks/useProjectByName";
+import { cn } from "@/react/lib/utils";
+import { PROJECT_V1_ROUTE_DETAIL } from "@/react/router/handles";
+import { useAppStore } from "@/react/stores/app";
+import { projectNamePrefix } from "@/store/modules/v1/common";
+import { extractProjectResourceName, hasWorkspacePermissionV2 } from "@/utils";
+
+export function ProjectLabel({
+ children,
+ projectName,
+ showResourceType = false,
+ className,
+ link,
+ onClick,
+ ...linkProps
+}: {
+ children?: ReactNode;
+ projectName: string;
+ showResourceType?: boolean;
+ link?: boolean;
+ onClick?: MouseEventHandler<HTMLAnchorElement>;
+} & Pick<RouterLinkProps, "className" | "rel" | "target">) {
+ const { t } = useTranslation();
+ const project = useProjectByName(projectName);
+ const projectId = extractProjectResourceName(projectName);
+ const validProjectName =
+ projectName.startsWith(projectNamePrefix) && projectId.length > 0;
+ const shouldFetchProject = children === undefined;
+
+ useEffect(() => {
+ if (
+ shouldFetchProject &&
+ validProjectName &&
+ hasWorkspacePermissionV2("bb.projects.get")
+ ) {
+ void useAppStore.getState().getOrFetchProjectByName(projectName, true);
+ }
+ }, [projectName, shouldFetchProject, validProjectName]);
+
+ if (!validProjectName) {
+ return (
+ <span className={className}>{children ?? (projectName || "-")}</span>
+ );
+ }
+
+ const label =
+ project.name === projectName && project.title ? project.title : projectId;
+ const content: ReactNode = children ?? (
+ <>
+ {showResourceType && (
+ <span className="mr-1 text-xs text-control-light">
+ {t("common.project")}:
+ </span>
+ )}
+ <span className="truncate">{label}</span>
+ </>
+ );
+
+ if (!link) {
+ if (className) {
+ return <span className={className}>{content}</span>;
+ }
+ return content;
+ }
+
+ return (
+ <RouterLink
+ {...linkProps}
+ to={{
+ name: PROJECT_V1_ROUTE_DETAIL,
+ params: { projectId },
+ }}
+ className={cn(
+ "inline-flex min-w-0 max-w-full normal-link hover:underline",
+ className
+ )}
+ onClick={(event) => {
+ event.stopPropagation();
+ onClick?.(event);
+ }}
+ >
+ {content}
+ </RouterLink>
+ );
+}
diff --git a/frontend/src/react/components/ProjectTable.test.tsx b/frontend/src/react/components/ProjectTable.test.tsx
index db106f8c73..43e16bd611 100644
--- a/frontend/src/react/components/ProjectTable.test.tsx
+++ b/frontend/src/react/components/ProjectTable.test.tsx
@@ -1,3 +1,4 @@
+import type { MouseEventHandler, ReactNode } from "react";
import { act } from "react";
import { createRoot } from "react-dom/client";
import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
@@ -19,6 +20,37 @@ vi.mock("@/react/components/ui/ellipsis-text", () => ({
),
}));
+vi.mock("@/react/components/ProjectLabel", () => ({
+ ProjectLabel: ({
+ children,
+ className,
+ link,
+ onClick,
+ projectName,
+ }: {
+ children: ReactNode;
+ className?: string;
+ link?: boolean;
+ onClick?: MouseEventHandler<HTMLAnchorElement>;
+ projectName: string;
+ }) =>
+ link ? (
+ <a
+ className={className}
+ data-project-name={projectName}
+ data-project-id={projectName.split("/").at(-1)}
+ onClick={(e) => {
+ e.stopPropagation();
+ onClick?.(e);
+ }}
+ >
+ {children}
+ </a>
+ ) : (
+ <span className={className}>{children}</span>
+ ),
+}));
+
const project = {
name: "projects/sample",
title: "Sample Project",
@@ -43,37 +75,26 @@ describe("ProjectTable", () => {
vi.clearAllMocks();
});
- test("renders project ID and title as links when a row href is provided", () => {
+ test("renders project ID as text and title as a settings table link", () => {
act(() => {
- root.render(
- <ProjectTable
- projectList={[project]}
- getRowHref={() => "/projects/sample/issues"}
- />
- );
+ root.render(<ProjectTable projectList={[project]} showActions />);
});
const links = [...container.querySelectorAll("a")];
- expect(links).toHaveLength(2);
- expect(links.map((link) => link.getAttribute("href"))).toEqual([
- "/projects/sample/issues",
- "/projects/sample/issues",
- ]);
- expect(links.map((link) => link.textContent)).toEqual([
- "sample",
- "Sample Project",
- ]);
+ expect(links).toHaveLength(1);
+ expect(links[0].dataset.projectName).toBe("projects/sample");
+ expect(links[0].dataset.projectId).toBe("sample");
+ expect(links[0].textContent).toBe("Sample Project");
+ expect(container.textContent).toContain("sample");
});
- test("keeps plain clicks on row links native without a row click handler", () => {
+ test("keeps plain clicks on settings table links native without a row click handler", () => {
act(() => {
- root.render(
- <ProjectTable projectList={[project]} getRowHref={() => "#sample"} />
- );
+ root.render(<ProjectTable projectList={[project]} showActions />);
});
const links = [...container.querySelectorAll("a")];
- expect(links).toHaveLength(2);
+ expect(links).toHaveLength(1);
for (const link of links) {
const notPrevented = link.dispatchEvent(
new MouseEvent("click", {
@@ -85,63 +106,62 @@ describe("ProjectTable", () => {
}
});
- test("routes plain clicks on row links through the row click handler", () => {
+ test("routes plain row clicks through the row click handler", () => {
const onRowClick = vi.fn();
act(() => {
root.render(
<ProjectTable
projectList={[project]}
- getRowHref={() => "/projects/sample/issues"}
+ showActions
onRowClick={onRowClick}
/>
);
});
- const links = [...container.querySelectorAll("a")];
- expect(links).toHaveLength(2);
- for (const link of links) {
- const event = new MouseEvent("click", {
- bubbles: true,
- cancelable: true,
- });
- const notPrevented = link.dispatchEvent(event);
- expect(notPrevented).toBe(false);
- }
+ expect(container.querySelectorAll("a")).toHaveLength(0);
+
+ const row = container.querySelector("tbody tr");
+ expect(row).not.toBeNull();
+ const event = new MouseEvent("click", {
+ bubbles: true,
+ cancelable: true,
+ });
+ const notPrevented = row?.dispatchEvent(event);
+ expect(notPrevented).toBe(true);
- expect(onRowClick).toHaveBeenCalledTimes(2);
- expect(onRowClick.mock.calls.map((call) => call[0])).toEqual([
- project,
- project,
- ]);
+ expect(onRowClick).toHaveBeenCalledTimes(1);
+ expect(onRowClick.mock.calls[0][0]).toBe(project);
});
- test("keeps modified clicks on row links native", () => {
+ test("passes modified row clicks through the row click handler", () => {
const onRowClick = vi.fn();
act(() => {
root.render(
<ProjectTable
projectList={[project]}
- getRowHref={() => "#sample"}
+ showActions
onRowClick={onRowClick}
/>
);
});
- const links = [...container.querySelectorAll("a")];
- expect(links).toHaveLength(2);
- for (const link of links) {
- const modifiedNotPrevented = link.dispatchEvent(
- new MouseEvent("click", {
- bubbles: true,
- cancelable: true,
- metaKey: true,
- })
- );
- expect(modifiedNotPrevented).toBe(true);
- }
+ expect(container.querySelectorAll("a")).toHaveLength(0);
- expect(onRowClick).not.toHaveBeenCalled();
+ const row = container.querySelector("tbody tr");
+ expect(row).not.toBeNull();
+ const modifiedNotPrevented = row?.dispatchEvent(
+ new MouseEvent("click", {
+ bubbles: true,
+ cancelable: true,
+ metaKey: true,
+ })
+ );
+ expect(modifiedNotPrevented).toBe(true);
+
+ expect(onRowClick).toHaveBeenCalledTimes(1);
+ expect(onRowClick.mock.calls[0][0]).toBe(project);
+ expect(onRowClick.mock.calls[0][1].metaKey).toBe(true);
});
});
diff --git a/frontend/src/react/components/ProjectTable.tsx b/frontend/src/react/components/ProjectTable.tsx
index 8c81a81191..570b09b458 100644
--- a/frontend/src/react/components/ProjectTable.tsx
+++ b/frontend/src/react/components/ProjectTable.tsx
@@ -3,7 +3,7 @@ import type { MouseEvent as ReactMouseEvent, ReactNode } from "react";
import { memo, useCallback, useMemo, useRef } from "react";
import { useTranslation } from "react-i18next";
import { HighlightLabelText } from "@/react/components/HighlightLabelText";
-import { RouterLink } from "@/react/components/RouterLink";
+import { ProjectLabel } from "@/react/components/ProjectLabel";
import { Badge } from "@/react/components/ui/badge";
import { Checkbox } from "@/react/components/ui/checkbox";
import { EllipsisText } from "@/react/components/ui/ellipsis-text";
@@ -59,8 +59,6 @@ export interface ProjectTableProps {
*/
readonly showActions?: boolean;
readonly renderActions?: RenderActions;
- /** Native link target for each row, used by title anchors. */
- readonly getRowHref?: (project: Project) => string;
/** Currently-checked rows (selection mode). */
readonly selectedProjectNames?: readonly string[];
/** Selection-change callback. */
@@ -101,7 +99,6 @@ export function ProjectTable({
showLabels = true,
showActions = false,
renderActions,
- getRowHref,
selectedProjectNames = [],
onSelectedChange,
sortKey,
@@ -147,8 +144,6 @@ export function ProjectTable({
onRowClickRef.current = onRowClick;
const renderActionsRef = useRef(renderActions);
renderActionsRef.current = renderActions;
- const getRowHrefRef = useRef(getRowHref);
- getRowHrefRef.current = getRowHref;
const handleSelectAll = useCallback(() => {
const cb = onSelectedChangeRef.current;
@@ -254,11 +249,9 @@ export function ProjectTable({
showLeadingCheck={showLeadingCheck}
showLabels={showLabels}
showActions={showActions}
- clickable={!!onRowClick}
- rowHref={getRowHrefRef.current?.(project)}
keyword={keyword}
onToggleRow={handleToggleRow}
- onRowClick={handleRowClick}
+ onRowClick={onRowClick ? handleRowClick : undefined}
renderActions={renderActionsStable}
/>
))
@@ -276,11 +269,9 @@ interface ProjectRowViewProps {
showLeadingCheck: boolean;
showLabels: boolean;
showActions: boolean;
- clickable: boolean;
- rowHref?: string;
keyword: string;
onToggleRow: (name: string) => void;
- onRowClick: (project: Project, event: ProjectRowClickEvent) => void;
+ onRowClick?: (project: Project, event: ProjectRowClickEvent) => void;
renderActions: (project: Project) => ReactNode;
}
@@ -292,8 +283,6 @@ const ProjectRowView = memo(function ProjectRowView({
showLeadingCheck,
showLabels,
showActions,
- clickable,
- rowHref,
keyword,
onToggleRow,
onRowClick,
@@ -313,24 +302,10 @@ const ProjectRowView = memo(function ProjectRowView({
<HighlightLabelText text={resourceId} keyword={keyword} />
</EllipsisText>
);
- const handleRowLinkClick = (event: ReactMouseEvent<HTMLAnchorElement>) => {
- event.stopPropagation();
- if (
- event.button !== 0 ||
- event.ctrlKey ||
- event.metaKey ||
- event.shiftKey ||
- event.altKey
- ) {
- return;
- }
- event.preventDefault();
- onRowClick(project, event);
- };
return (
<TableRow
- className={cn(clickable && "cursor-pointer")}
- onClick={clickable ? (event) => onRowClick(project, event) : undefined}
+ className={cn(onRowClick && "cursor-pointer")}
+ onClick={onRowClick ? (event) => onRowClick?.(project, event) : undefined}
>
{showSelection ? (
<TableCell
@@ -356,39 +331,17 @@ const ProjectRowView = memo(function ProjectRowView({
</TableCell>
) : null}
<TableCell>
- {rowHref && clickable ? (
- <RouterLink
- to={rowHref}
- className="block hover:underline"
- onClick={handleRowLinkClick}
- >
- {resourceIdContent}
- </RouterLink>
- ) : rowHref ? (
- <a href={rowHref} className="block hover:underline">
- {resourceIdContent}
- </a>
- ) : (
- resourceIdContent
- )}
+ {resourceIdContent}
</TableCell>
<TableCell>
<div className="flex items-center gap-x-2 min-w-0">
- {rowHref && clickable ? (
- <RouterLink
- to={rowHref}
- className="min-w-0 block hover:underline"
- onClick={handleRowLinkClick}
- >
- {titleContent}
- </RouterLink>
- ) : rowHref ? (
- <a href={rowHref} className="min-w-0 block hover:underline">
- {titleContent}
- </a>
- ) : (
- titleContent
- )}
+ <ProjectLabel
+ projectName={project.name}
+ link={!onRowClick}
+ className="min-w-0 block hover:underline"
+ >
+ {titleContent}
+ </ProjectLabel>
{project.state === State.DELETED ? (
<Badge variant="warning" className="text-xs shrink-0">
{t("common.archived")}
diff --git a/frontend/src/react/components/database/DatabaseTableView.tsx b/frontend/src/react/components/database/DatabaseTableView.tsx
index 9512dcc5d3..dfd480105b 100644
--- a/frontend/src/react/components/database/DatabaseTableView.tsx
+++ b/frontend/src/react/components/database/DatabaseTableView.tsx
@@ -11,6 +11,7 @@ import { useTranslation } from "react-i18next";
import { EngineIcon } from "@/react/components/EngineIcon";
import { EnvironmentBadge } from "@/react/components/EnvironmentLabel";
import { LabelsDisplay } from "@/react/components/LabelsDisplay";
+import { ProjectLabel } from "@/react/components/ProjectLabel";
import { Checkbox } from "@/react/components/ui/checkbox";
import { EllipsisText } from "@/react/components/ui/ellipsis-text";
import {
@@ -36,8 +37,6 @@ import { SyncStatus } from "@/types/proto-es/v1/database_service_pb";
import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";
import {
extractDatabaseResourceName,
- extractProjectResourceName,
- getDatabaseProject,
getInstanceResource,
hostPortOfInstanceV1,
} from "@/utils";
@@ -256,9 +255,11 @@ export function DatabaseTableView({
sortable: true,
sortKey: "project",
render: (db) => (
- <span className="truncate">
- {extractProjectResourceName(getDatabaseProject(db).name)}
- </span>
+ <ProjectLabel
+ projectName={db.project}
+ className="truncate"
+ link={true}
+ />
),
});
} else {
diff --git a/frontend/src/react/components/instance/InstanceActionDropdown.test.tsx b/frontend/src/react/components/instance/InstanceActionDropdown.test.tsx
new file mode 100644
index 0000000000..97108d8135
--- /dev/null
+++ b/frontend/src/react/components/instance/InstanceActionDropdown.test.tsx
@@ -0,0 +1,212 @@
+import { create } from "@bufbuild/protobuf";
+import { fireEvent } from "@testing-library/react";
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { State } from "@/types/proto-es/v1/common_pb";
+import { InstanceSchema } from "@/types/proto-es/v1/instance_service_pb";
+import { InstanceActionDropdown } from "./InstanceActionDropdown";
+
+(
+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+globalThis.ResizeObserver ??= class ResizeObserver {
+ observe() {}
+ unobserve() {}
+ disconnect() {}
+};
+
+const mocks = vi.hoisted(() => ({
+ hasWorkspacePermissionV2: vi.fn(() => true),
+ archiveInstance: vi.fn(),
+ restoreInstance: vi.fn(),
+ deleteInstance: vi.fn(),
+ routerReplace: vi.fn(),
+}));
+
+vi.mock("react-i18next", () => ({
+ initReactI18next: { type: "3rdParty", init: () => {} },
+ useTranslation: () => ({
+ t: (key: string) => key,
+ }),
+}));
+
+vi.mock("@/react/router", () => ({
+ router: {
+ replace: mocks.routerReplace,
+ },
+}));
+
+vi.mock("@/react/stores/app", () => ({
+ useAppStore: {
+ getState: () => ({
+ archiveInstance: mocks.archiveInstance,
+ restoreInstance: mocks.restoreInstance,
+ deleteInstance: mocks.deleteInstance,
+ }),
+ },
+}));
+
+vi.mock("@/store", () => ({
+ pushNotification: vi.fn(),
+}));
+
+vi.mock("@/utils", async () => {
+ const actual = await vi.importActual<typeof import("@/utils")>("@/utils");
+ return {
+ ...actual,
+ hasWorkspacePermissionV2: mocks.hasWorkspacePermissionV2,
+ };
+});
+
+const renderMenu = async (state: State) => {
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+ const instance = create(InstanceSchema, {
+ name: "instances/prod",
+ title: "Production",
+ state,
+ });
+
+ await act(async () => {
+ root.render(<InstanceActionDropdown instance={instance} />);
+ });
+ await act(async () => {
+ container
+ .querySelector("button")
+ ?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ });
+ await vi.waitFor(() => {
+ expect(document.body.querySelector("[role='menu']")).toBeTruthy();
+ });
+
+ return {
+ root,
+ text: () => document.body.textContent ?? "",
+ };
+};
+
+describe("InstanceActionDropdown", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ document.body.innerHTML = "";
+ });
+
+ test("offers permanent delete for an active instance", async () => {
+ const menu = await renderMenu(State.ACTIVE);
+
+ expect(menu.text()).toContain("common.archive");
+ expect(menu.text()).toContain("common.delete");
+
+ act(() => menu.root.unmount());
+ });
+
+ test("offers permanent delete for an archived instance", async () => {
+ const menu = await renderMenu(State.DELETED);
+
+ expect(menu.text()).toContain("common.restore");
+ expect(menu.text()).toContain("common.delete");
+
+ act(() => menu.root.unmount());
+ });
+
+ test("opens the archived instance list after archiving", async () => {
+ const confirmSpy = vi.spyOn(window, "confirm").mockReturnValue(true);
+ mocks.archiveInstance.mockResolvedValue(undefined);
+ const menu = await renderMenu(State.ACTIVE);
+ const archiveItem = Array.from(
+ document.body.querySelectorAll("[role='menuitem']")
+ ).find((el) => el.textContent === "common.archive");
+
+ await act(async () => {
+ archiveItem?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ await Promise.resolve();
+ });
+
+ expect(mocks.archiveInstance).toHaveBeenCalled();
+ expect(mocks.routerReplace).toHaveBeenCalledWith({
+ name: "workspace.instance",
+ query: { q: "state:DELETED" },
+ });
+
+ confirmSpy.mockRestore();
+ act(() => menu.root.unmount());
+ });
+
+ test("archives before purging an active instance after resource id confirmation", async () => {
+ mocks.archiveInstance.mockResolvedValue(undefined);
+ mocks.deleteInstance.mockResolvedValue(undefined);
+ const menu = await renderMenu(State.ACTIVE);
+ const deleteItem = Array.from(
+ document.body.querySelectorAll("[role='menuitem']")
+ ).find((el) => el.textContent === "common.delete");
+
+ await act(async () => {
+ deleteItem?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ });
+
+ const input = document.body.querySelector("input") as HTMLInputElement;
+ const deleteButtons = Array.from(
+ document.body.querySelectorAll("button")
+ ).filter((el) => el.textContent === "common.delete");
+ const dialogDeleteButton = deleteButtons.at(-1) as HTMLButtonElement;
+ expect(dialogDeleteButton.disabled).toBe(true);
+
+ await act(async () => {
+ fireEvent.change(input, { target: { value: "prod" } });
+ });
+ expect(dialogDeleteButton.disabled).toBe(false);
+
+ await act(async () => {
+ dialogDeleteButton.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ await Promise.resolve();
+ });
+
+ expect(mocks.archiveInstance).toHaveBeenCalledWith(
+ expect.objectContaining({ name: "instances/prod" }),
+ true
+ );
+ expect(mocks.deleteInstance).toHaveBeenCalledWith("instances/prod");
+ expect(mocks.archiveInstance.mock.invocationCallOrder[0]).toBeLessThan(
+ mocks.deleteInstance.mock.invocationCallOrder[0]
+ );
+ expect(mocks.routerReplace).toHaveBeenCalledWith({
+ name: "workspace.instance",
+ });
+
+ act(() => menu.root.unmount());
+ });
+
+ test("purges an archived instance after resource id confirmation", async () => {
+ mocks.deleteInstance.mockResolvedValue(undefined);
+ const menu = await renderMenu(State.DELETED);
+ const deleteItem = Array.from(
+ document.body.querySelectorAll("[role='menuitem']")
+ ).find((el) => el.textContent === "common.delete");
+
+ await act(async () => {
+ deleteItem?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ });
+
+ const input = document.body.querySelector("input") as HTMLInputElement;
+ const deleteButtons = Array.from(
+ document.body.querySelectorAll("button")
+ ).filter((el) => el.textContent === "common.delete");
+ const dialogDeleteButton = deleteButtons.at(-1) as HTMLButtonElement;
+
+ await act(async () => {
+ fireEvent.change(input, { target: { value: "prod" } });
+ });
+ await act(async () => {
+ dialogDeleteButton.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ await Promise.resolve();
+ });
+
+ expect(mocks.archiveInstance).not.toHaveBeenCalled();
+ expect(mocks.deleteInstance).toHaveBeenCalledWith("instances/prod");
+
+ act(() => menu.root.unmount());
+ });
+});
diff --git a/frontend/src/react/components/instance/InstanceActionDropdown.tsx b/frontend/src/react/components/instance/InstanceActionDropdown.tsx
index af679ebd0e..ec95a597fe 100644
--- a/frontend/src/react/components/instance/InstanceActionDropdown.tsx
+++ b/frontend/src/react/components/instance/InstanceActionDropdown.tsx
@@ -1,5 +1,5 @@
import { EllipsisVertical } from "lucide-react";
-import { useCallback } from "react";
+import { useCallback, useState } from "react";
import { useTranslation } from "react-i18next";
import {
DropdownMenu,
@@ -14,6 +14,7 @@ import { pushNotification } from "@/store";
import { State } from "@/types/proto-es/v1/common_pb";
import type { Instance } from "@/types/proto-es/v1/instance_service_pb";
import { hasWorkspacePermissionV2 } from "@/utils";
+import { InstanceDeleteDialog } from "./InstanceDeleteDialog";
interface InstanceActionDropdownProps {
instance: Instance;
@@ -25,6 +26,7 @@ export function InstanceActionDropdown({
onDeleted,
}: InstanceActionDropdownProps) {
const { t } = useTranslation();
+ const [showDeleteConfirm, setShowDeleteConfirm] = useState(false);
const canArchive = hasWorkspacePermissionV2("bb.instances.delete");
const canRestore = hasWorkspacePermissionV2("bb.instances.undelete");
@@ -46,7 +48,10 @@ export function InstanceActionDropdown({
0: instance.title,
}),
});
- router.replace({ name: INSTANCE_ROUTE_DASHBOARD });
+ router.replace({
+ name: INSTANCE_ROUTE_DASHBOARD,
+ query: { q: "state:DELETED" },
+ });
}, [instance, t]);
const handleRestore = useCallback(async () => {
@@ -69,55 +74,48 @@ export function InstanceActionDropdown({
});
}, [instance, t]);
- const handleDelete = useCallback(async () => {
- if (
- !window.confirm(
- `${t("common.delete-resource", { type: instance.title })}\n\n${t("common.cannot-undo-this-action")}`
- )
- )
- return;
-
- await useAppStore.getState().deleteInstance(instance.name);
- pushNotification({
- module: "bytebase",
- style: "SUCCESS",
- title: t("common.deleted"),
- });
- onDeleted?.();
- router.replace({
- name: INSTANCE_ROUTE_DASHBOARD,
- query: { q: "state:DELETED" },
- });
- }, [instance, t, onDeleted]);
-
const showArchive = instance.state === State.ACTIVE && canArchive;
const showRestore = instance.state === State.DELETED && canRestore;
- const showDelete = canArchive || canRestore;
+ const showDelete = canArchive;
if (!showArchive && !showRestore && !showDelete) return null;
return (
- <DropdownMenu>
- <DropdownMenuTrigger className="inline-flex items-center justify-center size-8 rounded-xs text-control hover:bg-control-bg cursor-pointer outline-hidden focus-visible:ring-2 focus-visible:ring-accent">
- <EllipsisVertical className="size-4" />
- </DropdownMenuTrigger>
- <DropdownMenuContent>
- {showArchive && (
- <DropdownMenuItem onClick={handleArchive}>
- {t("common.archive")}
- </DropdownMenuItem>
- )}
- {showRestore && (
- <DropdownMenuItem onClick={handleRestore}>
- {t("common.restore")}
- </DropdownMenuItem>
- )}
- {showDelete && (
- <DropdownMenuItem className="text-error" onClick={handleDelete}>
- {t("common.delete")}
- </DropdownMenuItem>
- )}
- </DropdownMenuContent>
- </DropdownMenu>
+ <>
+ <DropdownMenu>
+ <DropdownMenuTrigger className="inline-flex items-center justify-center size-8 rounded-xs text-control hover:bg-control-bg cursor-pointer outline-hidden focus-visible:ring-2 focus-visible:ring-accent">
+ <EllipsisVertical className="size-4" />
+ </DropdownMenuTrigger>
+ <DropdownMenuContent>
+ {showArchive && (
+ <DropdownMenuItem onClick={handleArchive}>
+ {t("common.archive")}
+ </DropdownMenuItem>
+ )}
+ {showRestore && (
+ <DropdownMenuItem onClick={handleRestore}>
+ {t("common.restore")}
+ </DropdownMenuItem>
+ )}
+ {showDelete && (
+ <DropdownMenuItem
+ className="text-error"
+ onClick={() => setShowDeleteConfirm(true)}
+ >
+ {t("common.delete")}
+ </DropdownMenuItem>
+ )}
+ </DropdownMenuContent>
+ </DropdownMenu>
+ <InstanceDeleteDialog
+ open={showDeleteConfirm}
+ instance={instance}
+ onOpenChange={setShowDeleteConfirm}
+ onDeleted={() => {
+ onDeleted?.();
+ router.replace({ name: INSTANCE_ROUTE_DASHBOARD });
+ }}
+ />
+ </>
);
}
diff --git a/frontend/src/react/components/instance/InstanceDeleteDialog.tsx b/frontend/src/react/components/instance/InstanceDeleteDialog.tsx
new file mode 100644
index 0000000000..3747506488
--- /dev/null
+++ b/frontend/src/react/components/instance/InstanceDeleteDialog.tsx
@@ -0,0 +1,122 @@
+import { useEffect, useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+import {
+ AlertDialog,
+ AlertDialogContent,
+ AlertDialogDescription,
+ AlertDialogTitle,
+} from "@/react/components/ui/alert-dialog";
+import { Button } from "@/react/components/ui/button";
+import { Input } from "@/react/components/ui/input";
+import { useAppStore } from "@/react/stores/app";
+import { pushNotification } from "@/store";
+import { State } from "@/types/proto-es/v1/common_pb";
+import type { Instance } from "@/types/proto-es/v1/instance_service_pb";
+import { extractInstanceResourceName } from "@/utils";
+
+interface InstanceDeleteDialogProps {
+ open: boolean;
+ instance: Instance;
+ onOpenChange: (open: boolean) => void;
+ onDeleted?: () => void;
+}
+
+export function InstanceDeleteDialog({
+ open,
+ instance,
+ onOpenChange,
+ onDeleted,
+}: InstanceDeleteDialogProps) {
+ const { t } = useTranslation();
+ const [confirmText, setConfirmText] = useState("");
+ const [deleting, setDeleting] = useState(false);
+ const instanceId = useMemo(
+ () => extractInstanceResourceName(instance.name),
+ [instance.name]
+ );
+ const isArchived = instance.state === State.DELETED;
+ const canConfirm = confirmText === instanceId && !deleting;
+ const description = isArchived
+ ? t("instance.delete-confirmation", {
+ id: instanceId,
+ name: instance.title,
+ })
+ : t("instance.delete-active-confirmation", {
+ id: instanceId,
+ name: instance.title,
+ });
+
+ useEffect(() => {
+ if (open) {
+ setConfirmText("");
+ setDeleting(false);
+ }
+ }, [open, instanceId]);
+
+ const handleDelete = async () => {
+ if (!canConfirm) return;
+
+ setDeleting(true);
+ try {
+ const store = useAppStore.getState();
+ if (!isArchived) {
+ await store.archiveInstance(instance, true);
+ }
+ await store.deleteInstance(instance.name);
+ pushNotification({
+ module: "bytebase",
+ style: "SUCCESS",
+ title: t("common.deleted"),
+ });
+ onOpenChange(false);
+ onDeleted?.();
+ } catch (error: unknown) {
+ pushNotification({
+ module: "bytebase",
+ style: "CRITICAL",
+ title: t("common.delete"),
+ description: (error as { message?: string }).message,
+ });
+ } finally {
+ setDeleting(false);
+ }
+ };
+
+ return (
+ <AlertDialog open={open} onOpenChange={onOpenChange}>
+ <AlertDialogContent className="max-w-lg">
+ <AlertDialogTitle>
+ {t("common.delete-resource", { type: instance.title })}
+ </AlertDialogTitle>
+ <AlertDialogDescription className="mt-2">
+ {description}
+ </AlertDialogDescription>
+ <div className="mt-4">
+ <Input
+ value={confirmText}
+ onChange={(event) => setConfirmText(event.target.value)}
+ placeholder={instanceId}
+ autoFocus
+ autoComplete="off"
+ />
+ </div>
+ <div className="mt-6 flex justify-end gap-x-2">
+ <Button
+ appearance="outline"
+ disabled={deleting}
+ onClick={() => onOpenChange(false)}
+ >
+ {t("common.cancel")}
+ </Button>
+ <Button
+ variant="destructive"
+ disabled={!canConfirm}
+ onClick={() => void handleDelete()}
+ >
+ {t("common.delete")}
+ </Button>
+ </div>
+ </AlertDialogContent>
+ </AlertDialog>
+ );
+}
diff --git a/frontend/src/react/components/instance/index.tsx b/frontend/src/react/components/instance/index.tsx
index 14871671e8..d75b8776d4 100644
--- a/frontend/src/react/components/instance/index.tsx
+++ b/frontend/src/react/components/instance/index.tsx
@@ -6,6 +6,7 @@ export { DataSourceForm } from "./DataSourceForm";
export { DataSourceSection } from "./DataSourceSection";
export { InfoPanel, InfoPanelContent } from "./InfoPanel";
export { InstanceActionDropdown } from "./InstanceActionDropdown";
+export { InstanceDeleteDialog } from "./InstanceDeleteDialog";
export { InstanceFormBody } from "./InstanceFormBody";
export { InstanceFormButtons } from "./InstanceFormButtons";
export {
diff --git a/frontend/src/react/components/sql-review/Panels.test.tsx b/frontend/src/react/components/sql-review/Panels.test.tsx
index 7fdb40df49..9bfc8a9d4a 100644
--- a/frontend/src/react/components/sql-review/Panels.test.tsx
+++ b/frontend/src/react/components/sql-review/Panels.test.tsx
@@ -122,6 +122,28 @@ beforeEach(async () => {
});
describe("RulesSelectPanel", () => {
+ test("uses the provided selected engine for the rule tabs", () => {
+ const { container, render, unmount } = renderIntoContainer(
+ <RulesSelectPanel
+ show
+ selectedRuleMap={new Map()}
+ selectedEngine={Engine.POSTGRES}
+ onClose={vi.fn()}
+ onRuleSelect={vi.fn()}
+ onRuleRemove={vi.fn()}
+ />
+ );
+
+ render();
+
+ const postgresTab = [...container.querySelectorAll('[role="tab"]')].find(
+ (tab) => tab.textContent?.includes("PostgreSQL")
+ );
+ expect(postgresTab?.getAttribute("aria-selected")).toBe("true");
+
+ unmount();
+ });
+
test("renders the first rule choices without blocking on the full list", () => {
const { container, render, unmount } = renderIntoContainer(
<RulesSelectPanel
diff --git a/frontend/src/react/components/sql-review/Panels.tsx b/frontend/src/react/components/sql-review/Panels.tsx
index 45c4676299..0d4da30ed7 100644
--- a/frontend/src/react/components/sql-review/Panels.tsx
+++ b/frontend/src/react/components/sql-review/Panels.tsx
@@ -47,7 +47,9 @@ const RULE_SELECT_RENDER_CHUNK_SIZE = 64;
interface RulesSelectPanelProps {
show: boolean;
selectedRuleMap: Map<Engine, Map<SQLReviewRule_Type, RuleTemplateV2>>;
+ selectedEngine?: Engine;
onClose: () => void;
+ onSelectedEngineChange?: (engine: Engine) => void;
onRuleSelect: (rule: RuleTemplateV2) => void;
onRuleRemove: (rule: RuleTemplateV2) => void;
}
@@ -55,7 +57,9 @@ interface RulesSelectPanelProps {
export function RulesSelectPanel({
show,
selectedRuleMap,
+ selectedEngine,
onClose,
+ onSelectedEngineChange,
onRuleSelect,
onRuleRemove,
}: RulesSelectPanelProps) {
@@ -121,7 +125,12 @@ export function RulesSelectPanel({
<SheetTitle>{t("sql-review.select-review-rules")}</SheetTitle>
</SheetHeader>
<SheetBody className="p-4">
- <TabsByEngine ruleMapByEngine={ruleTemplateMapV2} lazyPanels>
+ <TabsByEngine
+ ruleMapByEngine={ruleTemplateMapV2}
+ lazyPanels
+ selectedEngine={selectedEngine}
+ onSelectedEngineChange={onSelectedEngineChange}
+ >
{(ruleList, engine) => (
<RuleSelectListWithFilter
engine={engine}
diff --git a/frontend/src/react/components/sql-review/ResourceLink.test.tsx b/frontend/src/react/components/sql-review/ResourceLink.test.tsx
index c35e0be751..9850fbbdd3 100644
--- a/frontend/src/react/components/sql-review/ResourceLink.test.tsx
+++ b/frontend/src/react/components/sql-review/ResourceLink.test.tsx
@@ -91,7 +91,10 @@ beforeEach(async () => {
tags: { protected: "protected" },
});
mocks.usePlanFeature.mockReturnValue(true);
- mocks.useProjectByName.mockReturnValue({ title: "Sample project" });
+ mocks.useProjectByName.mockReturnValue({
+ name: "projects/sample",
+ title: "Sample project",
+ });
({ ResourceLink } = await import("./ResourceLink"));
});
diff --git a/frontend/src/react/components/sql-review/ResourceLink.tsx b/frontend/src/react/components/sql-review/ResourceLink.tsx
index 071ae0e627..2e8645f49f 100644
--- a/frontend/src/react/components/sql-review/ResourceLink.tsx
+++ b/frontend/src/react/components/sql-review/ResourceLink.tsx
@@ -1,20 +1,17 @@
import { ShieldAlert } from "lucide-react";
-import { useEffect } from "react";
import { useTranslation } from "react-i18next";
+import { ProjectLabel } from "@/react/components/ProjectLabel";
import {
RouterLink,
type RouterLinkProps,
} from "@/react/components/RouterLink";
import { useEnvironment, usePlanFeature } from "@/react/hooks/useAppState";
-import { useProjectByName } from "@/react/hooks/useProjectByName";
import { cn } from "@/react/lib/utils";
-import { useAppStore } from "@/react/stores/app";
import {
environmentNamePrefix,
projectNamePrefix,
} from "@/store/modules/v1/common";
import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";
-import { extractProjectResourceName, hasWorkspacePermissionV2 } from "@/utils";
type ResourceLinkAnchorProps = Pick<
RouterLinkProps,
@@ -40,8 +37,9 @@ export function ResourceLink({
}
if (resource.startsWith(projectNamePrefix)) {
return (
- <ProjectResourceLink
- resource={resource}
+ <ProjectLabel
+ projectName={resource}
+ link={true}
showResourceType={showResourceType}
{...linkProps}
/>
@@ -83,41 +81,3 @@ function EnvironmentResourceLink({
</RouterLink>
);
}
-
-function ProjectResourceLink({
- resource,
- showResourceType,
- className,
- ...linkProps
-}: {
- resource: string;
- showResourceType: boolean;
-} & ResourceLinkAnchorProps) {
- const { t } = useTranslation();
- // subscribe to re-render on project cache change
- const projectsByName = useAppStore((s) => s.projectsByName);
-
- useEffect(() => {
- if (hasWorkspacePermissionV2("bb.projects.get")) {
- useAppStore.getState().getOrFetchProjectByName(resource, true);
- }
- }, [resource]);
-
- const project = useProjectByName(resource);
- void projectsByName;
-
- return (
- <RouterLink
- {...linkProps}
- to={{ path: `/${resource}` }}
- className={cn("inline-flex items-center gap-x-1 normal-link", className)}
- >
- {showResourceType && (
- <span className="text-control-light text-xs mr-0.5">
- {t("common.project")}:
- </span>
- )}
- <span>{project?.title || extractProjectResourceName(resource)}</span>
- </RouterLink>
- );
-}
diff --git a/frontend/src/react/components/sql-review/ReviewCreation.test.tsx b/frontend/src/react/components/sql-review/ReviewCreation.test.tsx
index c8f2f91c03..39eab38b14 100644
--- a/frontend/src/react/components/sql-review/ReviewCreation.test.tsx
+++ b/frontend/src/react/components/sql-review/ReviewCreation.test.tsx
@@ -21,6 +21,8 @@ const mocks = vi.hoisted(() => ({
inputOnChange: vi.fn(),
resourceIdOnChange: vi.fn(),
ruleTableProps: [] as unknown[],
+ rulesSelectPanelProps: [] as unknown[],
+ tabsByEngineProps: [] as unknown[],
}));
let ReviewCreation: typeof import("./ReviewCreation").ReviewCreation;
@@ -124,19 +126,23 @@ vi.mock("./TemplateSelector", () => ({
}));
vi.mock("./TabsByEngine", () => ({
- TabsByEngine: ({
- ruleMapByEngine,
- children,
- }: {
+ TabsByEngine: (props: {
ruleMapByEngine: Map<Engine, Map<SQLReviewRule_Type, RuleTemplateV2>>;
children: (ruleList: RuleTemplateV2[], engine: Engine) => React.ReactNode;
- }) => (
- <div data-testid="tabs-by-engine">
- {[...ruleMapByEngine.entries()].map(([engine, ruleMap]) => (
- <div key={engine}>{children([...ruleMap.values()], engine)}</div>
- ))}
- </div>
- ),
+ selectedEngine?: Engine;
+ onSelectedEngineChange?: (engine: Engine) => void;
+ }) => {
+ mocks.tabsByEngineProps.push(props);
+ return (
+ <div data-testid="tabs-by-engine">
+ {[...props.ruleMapByEngine.entries()].map(([engine, ruleMap]) => (
+ <div key={engine}>
+ {props.children([...ruleMap.values()], engine)}
+ </div>
+ ))}
+ </div>
+ );
+ },
}));
vi.mock("./RuleTable", () => ({
@@ -147,7 +153,10 @@ vi.mock("./RuleTable", () => ({
}));
vi.mock("./Panels", () => ({
- RulesSelectPanel: () => <div data-testid="rules-select-panel" />,
+ RulesSelectPanel: (props: unknown) => {
+ mocks.rulesSelectPanelProps.push(props);
+ return <div data-testid="rules-select-panel" />;
+ },
}));
const renderIntoContainer = (element: ReactElement) => {
@@ -170,6 +179,8 @@ const renderIntoContainer = (element: ReactElement) => {
beforeEach(async () => {
vi.clearAllMocks();
mocks.ruleTableProps = [];
+ mocks.rulesSelectPanelProps = [];
+ mocks.tabsByEngineProps = [];
({ ReviewCreation } = await import("./ReviewCreation"));
});
@@ -317,4 +328,49 @@ describe("ReviewCreation", () => {
unmount();
});
+
+ test("opens the rule selection panel on the selected engine", () => {
+ const { container, render, unmount } = renderIntoContainer(
+ <ReviewCreation selectedRuleList={[]} selectedResources={[]} />
+ );
+
+ render();
+
+ act(() => {
+ mocks.resourceIdOnChange("custom-policy");
+ });
+ const nextButton = [...container.querySelectorAll("button")].find(
+ (button) => button.textContent === "common.next"
+ );
+ expect(nextButton).toBeTruthy();
+
+ act(() => {
+ nextButton!.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ });
+
+ const mainTabsProps = mocks.tabsByEngineProps.at(-1) as {
+ onSelectedEngineChange?: (engine: Engine) => void;
+ };
+ expect(mainTabsProps.onSelectedEngineChange).toBeTruthy();
+
+ act(() => {
+ mainTabsProps.onSelectedEngineChange?.(Engine.POSTGRES);
+ });
+
+ const addRulesButton = [...container.querySelectorAll("button")].find(
+ (button) => button.textContent === "sql-review.add-or-remove-rules"
+ );
+ expect(addRulesButton).toBeTruthy();
+
+ act(() => {
+ addRulesButton!.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ });
+
+ const panelProps = mocks.rulesSelectPanelProps.at(-1) as {
+ selectedEngine?: Engine;
+ };
+ expect(panelProps.selectedEngine).toBe(Engine.POSTGRES);
+
+ unmount();
+ });
});
diff --git a/frontend/src/react/components/sql-review/ReviewCreation.tsx b/frontend/src/react/components/sql-review/ReviewCreation.tsx
index a14dcfbb94..e46c5b622c 100644
--- a/frontend/src/react/components/sql-review/ReviewCreation.tsx
+++ b/frontend/src/react/components/sql-review/ReviewCreation.tsx
@@ -449,7 +449,9 @@ export function ReviewCreation({
<RulesSelectPanel
show={showRuleSelectPanel}
selectedRuleMap={ruleMapByEngine}
+ selectedEngine={focusedEngine}
onClose={() => setShowRuleSelectPanel(false)}
+ onSelectedEngineChange={setFocusedEngine}
onRuleSelect={(rule) => upsertRule(rule, {})}
onRuleRemove={removeRule}
/>
diff --git a/frontend/src/react/pages/settings/EnvironmentsPage.tsx b/frontend/src/react/pages/settings/EnvironmentsPage.tsx
index 332de28e45..4d401f7bbc 100644
--- a/frontend/src/react/pages/settings/EnvironmentsPage.tsx
+++ b/frontend/src/react/pages/settings/EnvironmentsPage.tsx
@@ -17,7 +17,7 @@ import {
} from "@dnd-kit/sortable";
import { CSS } from "@dnd-kit/utilities";
import { cloneDeep, isEqual } from "lodash-es";
-import { GripVertical, ListOrdered, Plus, ShieldAlert, X } from "lucide-react";
+import { GripVertical, ListOrdered, Plus, X } from "lucide-react";
import {
forwardRef,
useCallback,
@@ -28,6 +28,7 @@ import {
useState,
} from "react";
import { useTranslation } from "react-i18next";
+import { EnvironmentLabel } from "@/react/components/EnvironmentLabel";
import { FeatureAttention } from "@/react/components/FeatureAttention";
import { FeatureBadge } from "@/react/components/FeatureBadge";
import { LearnMoreLink } from "@/react/components/LearnMoreLink";
@@ -100,67 +101,12 @@ import {
} from "@/types/proto-es/v1/org_policy_service_pb";
import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";
import type { Environment } from "@/types/v1/environment";
-import {
- hasWorkspacePermissionV2,
- hexToRgb,
- sqlReviewPolicySlug,
-} from "@/utils";
+import { hasWorkspacePermissionV2, sqlReviewPolicySlug } from "@/utils";
import {
getEnvironmentListKey,
resolveSelectedEnvironmentId,
} from "./environmentSelection";
-// ============================================================
-// EnvironmentName - displays env name with color badge
-// ============================================================
-function EnvironmentName({
- environment,
- link = false,
-}: {
- environment: Environment;
- link?: boolean;
-}) {
- const hasEnvTierFeature = useAppStore((s) =>
- s.hasInstanceFeature(PlanFeature.FEATURE_ENVIRONMENT_TIERS)
- );
- const color = environment.color || DEFAULT_ENVIRONMENT_COLOR;
- const rgbValues = hexToRgb(color);
- const rgbStr = rgbValues.join(", ");
- const showProductionIcon =
- hasEnvTierFeature && environment.tags?.protected === "protected";
-
- const content = (
- <span
- className="inline-flex items-center gap-x-1 px-1.5 rounded-xs select-none truncate"
- style={{
- backgroundColor: `rgba(${rgbStr}, 0.1)`,
- color: `rgb(${rgbStr})`,
- }}
- >
- <span className="truncate">{environment.title}</span>
- {showProductionIcon && (
- <ShieldAlert className="w-3.5 h-3.5 shrink-0 text-control" />
- )}
- </span>
- );
-
- if (link) {
- return (
- <RouterLink
- to={{ path: `/${formatEnvironmentName(environment.id)}` }}
- onClick={(e) => {
- e.stopPropagation();
- }}
- className="hover:underline"
- >
- {content}
- </RouterLink>
- );
- }
-
- return content;
-}
-
// ============================================================
// Toggle switch
// ============================================================
@@ -1237,7 +1183,7 @@ function SortableEnvironmentRow({
>
<div className="flex items-center gap-x-2">
<span className="textinfo">{index + 1}.</span>
- <EnvironmentName environment={env} />
+ <EnvironmentLabel environment={env} />
</div>
<button
type="button"
@@ -1549,7 +1495,7 @@ export function EnvironmentsPage() {
{environmentList.map((env, index) => (
<TabsTrigger key={env.id} value={env.id} className="px-4">
<span className="opacity-60 mr-1">{index + 1}.</span>
- <EnvironmentName environment={env} />
+ <EnvironmentLabel environment={env} />
</TabsTrigger>
))}
<div className="flex-1" />
diff --git a/frontend/src/react/pages/settings/InstancesPage.tsx b/frontend/src/react/pages/settings/InstancesPage.tsx
index 02c3c91399..5b0ba7e2ac 100644
--- a/frontend/src/react/pages/settings/InstancesPage.tsx
+++ b/frontend/src/react/pages/settings/InstancesPage.tsx
@@ -20,6 +20,7 @@ import {
import { EngineIcon } from "@/react/components/EngineIcon";
import { EnvironmentLabel } from "@/react/components/EnvironmentLabel";
import { InstanceAssignmentSheet } from "@/react/components/InstanceAssignmentSheet";
+import { InstanceDeleteDialog } from "@/react/components/instance";
import { PermissionGuard } from "@/react/components/PermissionGuard";
import {
type SelectionAction,
@@ -87,18 +88,15 @@ import { environmentNamePrefix } from "@/store/modules/v1/common";
import {
DEFAULT_ENVIRONMENT_COLOR,
isValidInstanceName,
- NULL_ENVIRONMENT_NAME,
UNKNOWN_ENVIRONMENT_NAME,
unknownEnvironment,
} from "@/types";
import { Engine, State } from "@/types/proto-es/v1/common_pb";
import type { Instance } from "@/types/proto-es/v1/instance_service_pb";
import { UpdateInstanceRequestSchema } from "@/types/proto-es/v1/instance_service_pb";
-import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";
import {
engineNameV1,
hasWorkspacePermissionV2,
- hexToRgb,
hostPortOfDataSource,
hostPortOfInstanceV1,
supportedEngineV1List,
@@ -187,75 +185,6 @@ function ConfirmDialog({
);
}
-// ============================================================
-// EnvironmentName
-// ============================================================
-
-function EnvironmentName({ environmentName }: { environmentName: string }) {
- const { t } = useTranslation();
- const environmentList = useAppStore((s) => s.environmentList);
- const environment = useMemo(
- () =>
- useAppStore
- .getState()
- .getEnvironmentByName(environmentName || NULL_ENVIRONMENT_NAME),
- [environmentList, environmentName]
- );
-
- const isUnset =
- environment.name === UNKNOWN_ENVIRONMENT_NAME ||
- environment.name === NULL_ENVIRONMENT_NAME;
-
- const hasEnvTierFeature = useAppStore((s) =>
- s.hasInstanceFeature(PlanFeature.FEATURE_ENVIRONMENT_TIERS)
- );
- const isProtected =
- hasEnvTierFeature && environment.tags?.protected === "protected";
-
- const bgColorRgb = isUnset
- ? null
- : hexToRgb(environment.color || DEFAULT_ENVIRONMENT_COLOR);
-
- return (
- <span
- className="inline-flex items-center gap-x-1"
- style={
- bgColorRgb && !isUnset
- ? {
- backgroundColor: `rgba(${bgColorRgb.join(", ")}, 0.1)`,
- color: `rgb(${bgColorRgb.join(", ")})`,
- padding: "0 6px",
- borderRadius: "4px",
- }
- : undefined
- }
- >
- <span className="truncate">
- {isUnset ? (
- <span className="text-control-light italic">
- {t("common.unassigned")}
- </span>
- ) : (
- environment.title
- )}
- </span>
- {isProtected && !isUnset && (
- <svg
- className="w-4 h-4 shrink-0 text-current"
- viewBox="0 0 20 20"
- fill="currentColor"
- >
- <path
- fillRule="evenodd"
- d="M10 1.944A11.954 11.954 0 012.166 5C2.056 5.649 2 6.319 2 7c0 5.225 3.34 9.67 8 11.317C14.66 16.67 18 12.225 18 7c0-.682-.057-1.351-.166-2.001A11.954 11.954 0 0110 1.944zM11 14a1 1 0 11-2 0 1 1 0 012 0zm0-7a1 1 0 10-2 0v3a1 1 0 102 0V7z"
- clipRule="evenodd"
- />
- </svg>
- )}
- </span>
- );
-}
-
// ============================================================
// InstanceActionDropdown
// ============================================================
@@ -319,26 +248,6 @@ function InstanceActionDropdown({
}
}, [instance, t, onAction]);
- const handleDelete = useCallback(async () => {
- try {
- await useAppStore.getState().deleteInstance(instance.name);
- pushNotification({
- module: "bytebase",
- style: "SUCCESS",
- title: t("common.deleted"),
- });
- setShowDeleteConfirm(false);
- onAction();
- } catch (error: unknown) {
- pushNotification({
- module: "bytebase",
- style: "CRITICAL",
- title: t("common.delete"),
- description: (error as { message?: string }).message,
- });
- }
- }, [instance, t, onAction]);
-
if (!canArchive && !canRestore) return null;
const isActive = instance.state === State.ACTIVE;
@@ -373,7 +282,7 @@ function InstanceActionDropdown({
{t("common.restore")}
</DropdownMenuItem>
)}
- {(canArchive || canRestore) && (
+ {canArchive && (
<DropdownMenuItem
className="text-error"
onClick={(e) => {
@@ -410,16 +319,11 @@ function InstanceActionDropdown({
</label>
</ConfirmDialog>
- <ConfirmDialog
+ <InstanceDeleteDialog
open={showDeleteConfirm}
- variant="error"
- title={t("common.delete-resource", {
- type: instance.title,
- })}
- description={t("common.cannot-undo-this-action")}
- okText={t("common.delete")}
- onOk={handleDelete}
- onCancel={() => setShowDeleteConfirm(false)}
+ instance={instance}
+ onOpenChange={setShowDeleteConfirm}
+ onDeleted={onAction}
/>
</>
);
@@ -595,11 +499,26 @@ export function InstancesPage() {
title: t("common.state"),
description: t("issue.advanced-search.scope.state.description"),
options: [
- { value: "ACTIVE", keywords: ["active"] },
+ {
+ value: "ACTIVE",
+ keywords: ["active"],
+ custom: true,
+ render: () => <span>{t("common.active")}</span>,
+ },
...(canUndelete
? [
- { value: "DELETED", keywords: ["archived", "deleted"] },
- { value: "ALL", keywords: ["all"] },
+ {
+ value: "DELETED",
+ keywords: ["archived", "deleted"],
+ custom: true,
+ render: () => <span>{t("common.archived")}</span>,
+ },
+ {
+ value: "ALL",
+ keywords: ["all"],
+ custom: true,
+ render: () => <span>{t("common.all")}</span>,
+ },
]
: []),
],
@@ -998,7 +917,7 @@ export function InstancesPage() {
resizable: true,
sortable: true,
render: (instance) => (
- <EnvironmentName environmentName={instance.environment ?? ""} />
+ <EnvironmentLabel environmentName={instance.environment ?? ""} />
),
},
{
diff --git a/frontend/src/react/pages/settings/ProjectsPage.tsx b/frontend/src/react/pages/settings/ProjectsPage.tsx
index 814a5ffca4..81c21ba3ad 100644
--- a/frontend/src/react/pages/settings/ProjectsPage.tsx
+++ b/frontend/src/react/pages/settings/ProjectsPage.tsx
@@ -262,11 +262,26 @@ export function ProjectsPage() {
title: t("common.state"),
description: t("issue.advanced-search.scope.state.description"),
options: [
- { value: "ACTIVE", keywords: ["active"] },
+ {
+ value: "ACTIVE",
+ keywords: ["active"],
+ custom: true,
+ render: () => <span>{t("common.active")}</span>,
+ },
...(canUndelete
? [
- { value: "DELETED", keywords: ["archived", "deleted"] },
- { value: "ALL", keywords: ["all"] },
+ {
+ value: "DELETED",
+ keywords: ["archived", "deleted"],
+ custom: true,
+ render: () => <span>{t("common.archived")}</span>,
+ },
+ {
+ value: "ALL",
+ keywords: ["all"],
+ custom: true,
+ render: () => <span>{t("common.all")}</span>,
+ },
]
: []),
],
@@ -585,10 +600,6 @@ export function ProjectsPage() {
[]
);
- const getProjectHref = useCallback((project: Project) => {
- return router.resolve(projectIssuesRoute(project)).fullPath;
- }, []);
-
const handleProjectAction = useCallback(() => {
fetchProjects(true);
}, [fetchProjects]);
@@ -631,7 +642,6 @@ export function ProjectsPage() {
onAction={handleProjectAction}
/>
)}
- getRowHref={getProjectHref}
selectedProjectNames={Array.from(selectedNames)}
onSelectedChange={(names) => setSelectedNames(new Set(names))}
sortKey={sortKey}