Skip to content

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

chore: support search sa/wi (#21340)

ecmadao79bd1c854296
diff --git a/frontend/src/components/AccountMultiSelect.test.tsx b/frontend/src/components/AccountMultiSelect.test.tsx
index 61a3392c2d..09678696ba 100644
--- a/frontend/src/components/AccountMultiSelect.test.tsx
+++ b/frontend/src/components/AccountMultiSelect.test.tsx
@@ -9,6 +9,10 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
const mocks = vi.hoisted(() => ({
listUsers: vi.fn(),
listGroups: vi.fn(),
+ listServiceAccounts: vi.fn(),
+ listWorkloadIdentities: vi.fn(),
+ hasWorkspacePermission: vi.fn(),
+ hasProjectPermission: vi.fn(),
}));
vi.mock("react-i18next", () => ({
@@ -25,13 +29,19 @@ vi.mock("@/hooks/useClickOutside", () => ({
}));
vi.mock("@/stores/app", () => {
- const state = () => ({
+ const state = {
listUsers: mocks.listUsers,
listGroups: mocks.listGroups,
- });
+ listServiceAccounts: mocks.listServiceAccounts,
+ listWorkloadIdentities: mocks.listWorkloadIdentities,
+ projectsByName: {
+ "projects/project-1": { name: "projects/project-1" },
+ },
+ hasWorkspacePermission: mocks.hasWorkspacePermission,
+ hasProjectPermission: mocks.hasProjectPermission,
+ };
return {
- useAppStore: (selector: (s: ReturnType<typeof state>) => unknown) =>
- selector(state()),
+ useAppStore: (selector: (s: typeof state) => unknown) => selector(state),
};
});
@@ -42,7 +52,22 @@ vi.mock("@/types", () => ({
WORKLOAD_IDENTITY: 2,
},
ALL_USERS_USER_EMAIL: "allUsers",
- getAccountTypeByEmail: () => 0,
+ getAccountTypeByFullname: (value: string) =>
+ value.startsWith("serviceAccounts/")
+ ? 1
+ : value.startsWith("workloadIdentities/")
+ ? 2
+ : 0,
+ getAccountTypeByEmail: (value: string) =>
+ !value.includes(":") && value.endsWith("@service.bytebase.com")
+ ? 1
+ : !value.includes(":") && value.endsWith("@workload.bytebase.com")
+ ? 2
+ : 0,
+ getServiceAccountNameInBinding: (email: string) => `serviceAccount:${email}`,
+ getWorkloadIdentityNameInBinding: (email: string) =>
+ `workloadIdentity:${email}`,
+ groupBindingPrefix: "group:",
serviceAccountBindingPrefix: "serviceAccount:",
userBindingPrefix: "user:",
workloadIdentityBindingPrefix: "workloadIdentity:",
@@ -82,6 +107,8 @@ let AccountMultiSelect: typeof import("./AccountMultiSelect").AccountMultiSelect
beforeEach(async () => {
vi.useFakeTimers();
+ mocks.hasWorkspacePermission.mockReturnValue(true);
+ mocks.hasProjectPermission.mockReturnValue(true);
mocks.listUsers.mockResolvedValue({
users: [
{
@@ -93,6 +120,14 @@ beforeEach(async () => {
nextPageToken: "",
});
mocks.listGroups.mockResolvedValue({ groups: [], nextPageToken: "" });
+ mocks.listServiceAccounts.mockResolvedValue({
+ serviceAccounts: [],
+ nextPageToken: "",
+ });
+ mocks.listWorkloadIdentities.mockResolvedValue({
+ workloadIdentities: [],
+ nextPageToken: "",
+ });
({ AccountMultiSelect } = await import("./AccountMultiSelect"));
});
@@ -286,4 +321,400 @@ describe("AccountMultiSelect", () => {
expect(container.textContent).toContain("Add users or groups");
act(() => root.unmount());
});
+
+ test("hides the all-users shortcut while searching", async () => {
+ mocks.listUsers.mockResolvedValue({ users: [], nextPageToken: "" });
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+ await act(async () => {
+ root.render(
+ <AccountMultiSelect
+ value={[]}
+ onChange={() => {}}
+ includeAllUsers
+ />
+ );
+ await Promise.resolve();
+ });
+ await act(async () => {
+ container.firstElementChild?.firstElementChild?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+ expect(container.textContent).toContain("settings.members.all-users");
+
+ const input = container.querySelector(
+ '[data-testid="search"]'
+ ) as HTMLInputElement;
+ await act(async () => {
+ const valueSetter = Object.getOwnPropertyDescriptor(
+ HTMLInputElement.prototype,
+ "value"
+ )?.set;
+ valueSetter?.call(input, "terr");
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ await Promise.resolve();
+ });
+
+ expect(container.textContent).not.toContain("settings.members.all-users");
+ expect(container.textContent).toContain("common.no-data");
+ act(() => root.unmount());
+ });
+
+ test("renders special account chips with their canonical email", () => {
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+ act(() => {
+ root.render(
+ <AccountMultiSelect
+ value={[
+ "serviceAccount:[email protected]",
+ "workloadIdentity:[email protected]",
+ ]}
+ onChange={() => {}}
+ />
+ );
+ });
+
+ expect(container.textContent).toContain("[email protected]");
+ expect(container.textContent).toContain("[email protected]");
+ act(() => root.unmount());
+ });
+
+ test("does not offer malformed special account identifiers", async () => {
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+ await act(async () => {
+ root.render(<AccountMultiSelect value={[]} onChange={() => {}} />);
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+ await act(async () => {
+ container.firstElementChild?.firstElementChild?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+
+ const input = container.querySelector(
+ '[data-testid="search"]'
+ ) as HTMLInputElement;
+ await act(async () => {
+ const valueSetter = Object.getOwnPropertyDescriptor(
+ HTMLInputElement.prototype,
+ "value"
+ )?.set;
+ valueSetter?.call(input, "serviceAccounts/not-an-email");
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(container.textContent).not.toContain(
+ "settings.members.service-account"
+ );
+ act(() => root.unmount());
+ });
+
+ test("does not treat IAM member bindings as search input", async () => {
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+ await act(async () => {
+ root.render(<AccountMultiSelect value={[]} onChange={() => {}} />);
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+ await act(async () => {
+ container.firstElementChild?.firstElementChild?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+
+ const input = container.querySelector(
+ '[data-testid="search"]'
+ ) as HTMLInputElement;
+ await act(async () => {
+ const valueSetter = Object.getOwnPropertyDescriptor(
+ HTMLInputElement.prototype,
+ "value"
+ )?.set;
+ valueSetter?.call(input, "serviceAccount:[email protected]");
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(container.textContent).not.toContain(
+ "settings.members.service-account"
+ );
+ act(() => root.unmount());
+ });
+
+ test("discovers a service account by partial search and serializes its binding", async () => {
+ mocks.listServiceAccounts.mockResolvedValue({
+ serviceAccounts: [
+ {
+ name: "serviceAccounts/[email protected]",
+ email: "[email protected]",
+ title: "Deploy bot",
+ },
+ ],
+ nextPageToken: "",
+ });
+ const onChange = vi.fn();
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+ await act(async () => {
+ root.render(
+ <AccountMultiSelect
+ value={[]}
+ onChange={onChange}
+ accountParents={["workspaces/default"]}
+ />
+ );
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+ await act(async () => {
+ container.firstElementChild?.firstElementChild?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+
+ const input = container.querySelector(
+ '[data-testid="search"]'
+ ) as HTMLInputElement;
+ await act(async () => {
+ const valueSetter = Object.getOwnPropertyDescriptor(
+ HTMLInputElement.prototype,
+ "value"
+ )?.set;
+ valueSetter?.call(input, "deploy");
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(container.textContent).toContain("Deploy bot");
+ expect(mocks.listServiceAccounts).toHaveBeenLastCalledWith({
+ parent: "workspaces/default",
+ pageSize: 50,
+ showDeleted: false,
+ filter: { query: "deploy" },
+ skipCache: true,
+ });
+ const deployBot = Array.from(container.querySelectorAll("b")).find(
+ (element) => element.textContent === "Deploy bot"
+ );
+ await act(async () => {
+ deployBot?.closest(".cursor-pointer")?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+ expect(onChange).toHaveBeenCalledWith([
+ "serviceAccount:[email protected]",
+ ]);
+ act(() => root.unmount());
+ });
+
+ test("queries each parent, deduplicates discovered accounts, and supports workload identities", async () => {
+ mocks.listServiceAccounts.mockResolvedValue({
+ serviceAccounts: [
+ {
+ name: "serviceAccounts/[email protected]",
+ email: "[email protected]",
+ title: "Deploy bot",
+ },
+ ],
+ nextPageToken: "",
+ });
+ mocks.listWorkloadIdentities.mockResolvedValue({
+ workloadIdentities: [
+ {
+ name: "workloadIdentities/[email protected]",
+ email: "[email protected]",
+ title: "CI bot",
+ },
+ ],
+ nextPageToken: "",
+ });
+ const onChange = vi.fn();
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+ await act(async () => {
+ root.render(
+ <AccountMultiSelect
+ value={[]}
+ onChange={onChange}
+ accountParents={["workspaces/default", "projects/project-1"]}
+ />
+ );
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+ await act(async () => {
+ container.firstElementChild?.firstElementChild?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+
+ const input = container.querySelector(
+ '[data-testid="search"]'
+ ) as HTMLInputElement;
+ await act(async () => {
+ const valueSetter = Object.getOwnPropertyDescriptor(
+ HTMLInputElement.prototype,
+ "value"
+ )?.set;
+ valueSetter?.call(input, "ci");
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(
+ mocks.listServiceAccounts.mock.calls
+ .slice(-2)
+ .map(([params]) => params.parent)
+ ).toEqual(["workspaces/default", "projects/project-1"]);
+ expect(container.textContent).toContain("settings.members.service-accounts");
+ expect(container.textContent).toContain(
+ "settings.members.workload-identities"
+ );
+ expect(container.textContent?.match(/Deploy bot/g)).toHaveLength(1);
+ const ciBot = Array.from(container.querySelectorAll("b")).find(
+ (element) => element.textContent === "CI bot"
+ );
+ await act(async () => {
+ ciBot?.closest(".cursor-pointer")?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+ expect(onChange).toHaveBeenCalledWith([
+ "workloadIdentity:[email protected]",
+ ]);
+ act(() => root.unmount());
+ });
+
+ test("hides excluded special accounts and preserves exact-email fallback after list failure", async () => {
+ mocks.listServiceAccounts.mockRejectedValue(new Error("forbidden"));
+ mocks.listWorkloadIdentities.mockRejectedValue(new Error("forbidden"));
+ const onChange = vi.fn();
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+ await act(async () => {
+ root.render(
+ <AccountMultiSelect
+ value={[]}
+ onChange={onChange}
+ accountParents={["workspaces/default"]}
+ excludeAccounts={["serviceAccount:[email protected]"]}
+ />
+ );
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+ await act(async () => {
+ container.firstElementChild?.firstElementChild?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+
+ const input = container.querySelector(
+ '[data-testid="search"]'
+ ) as HTMLInputElement;
+ const valueSetter = Object.getOwnPropertyDescriptor(
+ HTMLInputElement.prototype,
+ "value"
+ )?.set;
+ await act(async () => {
+ valueSetter?.call(input, "[email protected]");
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(container.textContent).not.toContain(
+ "settings.members.service-account"
+ );
+
+ await act(async () => {
+ valueSetter?.call(input, "[email protected]");
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+ const ci = Array.from(container.querySelectorAll("b")).find(
+ (element) => element.textContent === "ci"
+ );
+ await act(async () => {
+ ci?.closest(".cursor-pointer")?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+ expect(onChange).toHaveBeenCalledWith([
+ "workloadIdentity:[email protected]",
+ ]);
+ act(() => root.unmount());
+ });
+
+ test("does not list special accounts without permission but keeps exact-email fallback", async () => {
+ mocks.hasWorkspacePermission.mockReturnValue(false);
+ mocks.hasProjectPermission.mockReturnValue(false);
+ mocks.listServiceAccounts.mockClear();
+ mocks.listWorkloadIdentities.mockClear();
+ const onChange = vi.fn();
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ const root = createRoot(container);
+ await act(async () => {
+ root.render(
+ <AccountMultiSelect
+ value={[]}
+ onChange={onChange}
+ accountParents={["workspaces/default", "projects/project-1"]}
+ />
+ );
+ await Promise.resolve();
+ });
+
+ expect(mocks.listServiceAccounts).not.toHaveBeenCalled();
+ expect(mocks.listWorkloadIdentities).not.toHaveBeenCalled();
+
+ await act(async () => {
+ container.firstElementChild?.firstElementChild?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+ const input = container.querySelector(
+ '[data-testid="search"]'
+ ) as HTMLInputElement;
+ await act(async () => {
+ const valueSetter = Object.getOwnPropertyDescriptor(
+ HTMLInputElement.prototype,
+ "value"
+ )?.set;
+ valueSetter?.call(input, "[email protected]");
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ await Promise.resolve();
+ });
+ const deploy = Array.from(container.querySelectorAll("b")).find(
+ (element) => element.textContent === "deploy"
+ );
+ await act(async () => {
+ deploy?.closest(".cursor-pointer")?.dispatchEvent(
+ new MouseEvent("click", { bubbles: true })
+ );
+ });
+ expect(onChange).toHaveBeenCalledWith([
+ "serviceAccount:[email protected]",
+ ]);
+ act(() => root.unmount());
+ });
});
diff --git a/frontend/src/components/AccountMultiSelect.tsx b/frontend/src/components/AccountMultiSelect.tsx
index 3cdcde836e..5d47876ebd 100644
--- a/frontend/src/components/AccountMultiSelect.tsx
+++ b/frontend/src/components/AccountMultiSelect.tsx
@@ -9,110 +9,96 @@ import { useClickOutside } from "@/hooks/useClickOutside";
import { cn } from "@/lib/utils";
import { useAppStore } from "@/stores/app";
import {
+ extractServiceAccountId,
extractUserEmail,
+ extractWorkloadIdentityId,
groupNamePrefix,
+ projectNamePrefix,
serviceAccountNamePrefix,
workloadIdentityNamePrefix,
+ workspaceNamePrefix,
} from "@/stores/modules/v1/common";
import {
AccountType,
ALL_USERS_USER_EMAIL,
getAccountTypeByEmail,
- serviceAccountBindingPrefix,
- userBindingPrefix,
- workloadIdentityBindingPrefix,
+ getAccountTypeByFullname,
} from "@/types";
import type { Group } from "@/types/proto-es/v1/group_service_pb";
import type { User } from "@/types/proto-es/v1/user_service_pb";
import { getDefaultPagination, isValidEmail } from "@/utils";
+import {
+ convertFullnameToMember,
+ convertMemberToFullname,
+} from "@/utils/v1/iam";
import { getAvatarColor, getInitials } from "./UserAvatar";
// ---- Account type detection ----
//
-// Routes typed input to the right account type. Uses the canonical helpers
-// from @/types/v1/user so project-scoped emails like
-// "foo@<project>.workload.bytebase.com" are recognized — a hardcoded
-// "@workload.bytebase.com" suffix would miss them and fall through to a
-// `user:` binding.
-
-type SpecialAccountType = "serviceAccount" | "workloadIdentity";
+// Routes typed input to the right account type.
-function detectSpecialAccount(input: string): {
- type: SpecialAccountType;
+function getSpecialAccountByFullname(fullname: string): {
+ type: AccountType;
email: string;
} | null {
- const trimmed = input.trim();
- if (!trimmed) return null;
-
- // Canonical resource-name prefix (case-sensitive, matches backend AIP names).
- if (trimmed.startsWith(serviceAccountNamePrefix)) {
- return {
- type: "serviceAccount",
- email: trimmed.slice(serviceAccountNamePrefix.length),
- };
- }
- if (trimmed.startsWith(workloadIdentityNamePrefix)) {
- return {
- type: "workloadIdentity",
- email: trimmed.slice(workloadIdentityNamePrefix.length),
- };
- }
- // IAM binding prefix (`serviceAccount:` / `workloadIdentity:`).
- if (trimmed.startsWith(serviceAccountBindingPrefix)) {
- return {
- type: "serviceAccount",
- email: trimmed.slice(serviceAccountBindingPrefix.length),
- };
- }
- if (trimmed.startsWith(workloadIdentityBindingPrefix)) {
- return {
- type: "workloadIdentity",
- email: trimmed.slice(workloadIdentityBindingPrefix.length),
- };
+ switch (getAccountTypeByFullname(fullname)) {
+ case AccountType.SERVICE_ACCOUNT: {
+ const email = extractServiceAccountId(fullname);
+ return isValidEmail(email)
+ ? { type: AccountType.SERVICE_ACCOUNT, email }
+ : null;
+ }
+ case AccountType.WORKLOAD_IDENTITY: {
+ const email = extractWorkloadIdentityId(fullname);
+ return isValidEmail(email)
+ ? { type: AccountType.WORKLOAD_IDENTITY, email }
+ : null;
+ }
+ default:
+ return null;
}
- // Fallback: classify by email suffix using the canonical detector, which
- // matches both the root and project-scoped variants.
- switch (getAccountTypeByEmail(trimmed)) {
+}
+
+function getSpecialAccountByEmail(email: string): {
+ type: AccountType;
+ email: string;
+} | null {
+ if (!isValidEmail(email)) return null;
+
+ switch (getAccountTypeByEmail(email)) {
case AccountType.SERVICE_ACCOUNT:
- return { type: "serviceAccount", email: trimmed };
+ return { type: AccountType.SERVICE_ACCOUNT, email };
case AccountType.WORKLOAD_IDENTITY:
- return { type: "workloadIdentity", email: trimmed };
+ return { type: AccountType.WORKLOAD_IDENTITY, email };
default:
return null;
}
}
-// ---- Conversion helpers ----
-
-// binding → fullname
-function bindingToFullname(binding: string): string {
- if (binding === ALL_USERS_USER_EMAIL) return ALL_USERS_USER_EMAIL;
- if (binding.startsWith("user:"))
- return `users/${binding.slice("user:".length)}`;
- if (binding.startsWith("group:"))
- return `${groupNamePrefix}${binding.slice("group:".length)}`;
- if (binding.startsWith("serviceAccount:"))
- return `serviceAccounts/${binding.slice("serviceAccount:".length)}`;
- if (binding.startsWith("workloadIdentity:"))
- return `workloadIdentities/${binding.slice("workloadIdentity:".length)}`;
- return binding;
-}
+function detectSpecialAccount(input: string): {
+ type: AccountType;
+ email: string;
+} | null {
+ const email = input.trim();
+ if (!email) return null;
-// fullname → binding
-function fullnameToBinding(fullname: string): string {
- if (fullname === ALL_USERS_USER_EMAIL) return ALL_USERS_USER_EMAIL;
- if (fullname.startsWith("users/"))
- return `${userBindingPrefix}${fullname.slice("users/".length)}`;
- if (fullname.startsWith(groupNamePrefix))
- return `group:${fullname.slice(groupNamePrefix.length)}`;
- if (fullname.startsWith("serviceAccounts/"))
- return `serviceAccount:${fullname.slice("serviceAccounts/".length)}`;
- if (fullname.startsWith("workloadIdentities/"))
- return `workloadIdentity:${fullname.slice("workloadIdentities/".length)}`;
- return fullname;
+ return getSpecialAccountByFullname(email) ?? getSpecialAccountByEmail(email);
}
+type SpecialAccount = {
+ type: AccountType;
+ fullname: string;
+ email: string;
+ title?: string;
+};
+
+type AccountParent = {
+ name: string;
+ canListServiceAccounts: boolean;
+ canListWorkloadIdentities: boolean;
+};
+
// ---- Sub-components ----
function SelectionCheckbox({ selected }: { selected: boolean }) {
@@ -137,12 +123,12 @@ function SpecialAccountOption({
onToggle,
}: {
keyword: string;
- match: { type: SpecialAccountType; email: string };
+ match: SpecialAccount;
selected: boolean;
onToggle: () => void;
}) {
const { t } = useTranslation();
- const isServiceAccount = match.type === "serviceAccount";
+ const isServiceAccount = match.type === AccountType.SERVICE_ACCOUNT;
const Icon = isServiceAccount ? KeyRound : Shield;
const label = isServiceAccount
? t("settings.members.service-account")
@@ -166,7 +152,7 @@ function SpecialAccountOption({
<div className="flex flex-col min-w-0">
<div className="flex items-center gap-x-1">
<HighlightLabelText
- text={match.email.split("@")[0]}
+ text={match.title || match.email.split("@")[0]}
keyword={keyword}
className="text-sm font-medium truncate"
/>
@@ -192,6 +178,7 @@ export function AccountMultiSelect({
disabled,
includeAllUsers,
excludeAccounts,
+ accountParents,
placeholder,
}: {
value: string[];
@@ -207,16 +194,100 @@ export function AccountMultiSelect({
* chips already in `value` keep rendering and stay removable.
*/
excludeAccounts?: string[];
+ /** Resource parents whose special accounts may be discovered. */
+ accountParents?: string[];
}) {
const { t } = useTranslation();
const listUsers = useAppStore((state) => state.listUsers);
const listGroups = useAppStore((state) => state.listGroups);
+ const listServiceAccounts = useAppStore((state) => state.listServiceAccounts);
+ const listWorkloadIdentities = useAppStore(
+ (state) => state.listWorkloadIdentities
+ );
const currentUser = useCurrentUser();
const [open, setOpen] = useState(false);
const [search, setSearch] = useState("");
const [users, setUsers] = useState<User[]>([]);
const [groups, setGroups] = useState<Group[]>([]);
+ const [specialAccounts, setSpecialAccounts] = useState<SpecialAccount[]>([]);
+
+ const uniqueAccountParents = useMemo(
+ () => [...new Set(accountParents?.filter(Boolean) ?? [])],
+ [accountParents]
+ );
+ const workspaceAccountParent = useMemo(
+ () =>
+ uniqueAccountParents.find((parent) =>
+ parent.startsWith(workspaceNamePrefix)
+ ),
+ [uniqueAccountParents]
+ );
+ const projectAccountParent = useMemo(
+ () =>
+ uniqueAccountParents.find((parent) =>
+ parent.startsWith(projectNamePrefix)
+ ),
+ [uniqueAccountParents]
+ );
+ const project = useAppStore((state) =>
+ projectAccountParent
+ ? state.projectsByName[projectAccountParent]
+ : undefined
+ );
+ const canListWorkspaceServiceAccounts = useAppStore((state) =>
+ workspaceAccountParent
+ ? state.hasWorkspacePermission("bb.serviceAccounts.list")
+ : false
+ );
+ const canListWorkspaceWorkloadIdentities = useAppStore((state) =>
+ workspaceAccountParent
+ ? state.hasWorkspacePermission("bb.workloadIdentities.list")
+ : false
+ );
+ const canListProjectServiceAccounts = useAppStore((state) =>
+ project
+ ? state.hasProjectPermission(project, "bb.serviceAccounts.list")
+ : false
+ );
+ const canListProjectWorkloadIdentities = useAppStore((state) =>
+ project
+ ? state.hasProjectPermission(project, "bb.workloadIdentities.list")
+ : false
+ );
+ const permittedAccountParents = useMemo((): AccountParent[] => {
+ const parents: AccountParent[] = [];
+ if (
+ workspaceAccountParent &&
+ (canListWorkspaceServiceAccounts || canListWorkspaceWorkloadIdentities)
+ ) {
+ parents.push({
+ name: workspaceAccountParent,
+ canListServiceAccounts: canListWorkspaceServiceAccounts,
+ canListWorkloadIdentities: canListWorkspaceWorkloadIdentities,
+ });
+ }
+ if (
+ projectAccountParent &&
+ project &&
+ (canListProjectServiceAccounts || canListProjectWorkloadIdentities)
+ ) {
+ parents.push({
+ name: projectAccountParent,
+ canListServiceAccounts: canListProjectServiceAccounts,
+ canListWorkloadIdentities: canListProjectWorkloadIdentities,
+ });
+ }
+ return parents;
+ }, [
+ workspaceAccountParent,
+ canListWorkspaceServiceAccounts,
+ canListWorkspaceWorkloadIdentities,
+ projectAccountParent,
+ project,
+ canListProjectServiceAccounts,
+ canListProjectWorkloadIdentities,
+ ]);
const containerRef = useRef<HTMLDivElement>(null);
const inputRef = useRef<HTMLInputElement>(null);
@@ -237,6 +308,71 @@ export function AccountMultiSelect({
);
}, [search, listUsers, listGroups, excludeAccounts]);
+ useEffect(() => {
+ if (permittedAccountParents.length === 0) {
+ setSpecialAccounts([]);
+ return;
+ }
+
+ let cancelled = false;
+ const query = search.trim();
+ const pageSize = getDefaultPagination() + (excludeAccounts?.length ?? 0);
+ const params = (parent: string) => ({
+ parent,
+ pageSize,
+ showDeleted: false,
+ filter: { query },
+ skipCache: true,
+ });
+
+ void Promise.allSettled(
+ permittedAccountParents.flatMap((parent) => [
+ ...(parent.canListServiceAccounts
+ ? [listServiceAccounts(params(parent.name))]
+ : []),
+ ...(parent.canListWorkloadIdentities
+ ? [listWorkloadIdentities(params(parent.name))]
+ : []),
+ ])
+ ).then((results) => {
+ if (cancelled) return;
+ const discovered = new Map<string, SpecialAccount>();
+ for (const result of results) {
+ if (result.status !== "fulfilled") continue;
+ if ("serviceAccounts" in result.value) {
+ for (const account of result.value.serviceAccounts) {
+ discovered.set(account.name, {
+ type: AccountType.SERVICE_ACCOUNT,
+ fullname: account.name,
+ email: account.email,
+ title: account.title,
+ });
+ }
+ } else {
+ for (const account of result.value.workloadIdentities) {
+ discovered.set(account.name, {
+ type: AccountType.WORKLOAD_IDENTITY,
+ fullname: account.name,
+ email: account.email,
+ title: account.title,
+ });
+ }
+ }
+ }
+ setSpecialAccounts([...discovered.values()]);
+ });
+
+ return () => {
+ cancelled = true;
+ };
+ }, [
+ search,
+ permittedAccountParents,
+ listServiceAccounts,
+ listWorkloadIdentities,
+ excludeAccounts,
+ ]);
+
const handleClickOutside = useCallback(() => {
setOpen(false);
setSearch("");
@@ -245,12 +381,12 @@ export function AccountMultiSelect({
// Selected fullnames set for quick lookup
const selectedFullnames = useMemo(
- () => new Set(value.map(bindingToFullname)),
+ () => new Set(value.map(convertMemberToFullname)),
[value]
);
const excludedFullnames = useMemo(
- () => new Set((excludeAccounts ?? []).map(bindingToFullname)),
+ () => new Set((excludeAccounts ?? []).map(convertMemberToFullname)),
[excludeAccounts]
);
// Filter the rendered lists only — `users`/`groups` stay complete so
@@ -263,10 +399,31 @@ export function AccountMultiSelect({
() => groups.filter((group) => !excludedFullnames.has(group.name)),
[groups, excludedFullnames]
);
+ const visibleSpecialAccounts = useMemo(
+ () =>
+ specialAccounts.filter(
+ (account) => !excludedFullnames.has(account.fullname)
+ ),
+ [specialAccounts, excludedFullnames]
+ );
+ const visibleServiceAccounts = useMemo(
+ () =>
+ visibleSpecialAccounts.filter(
+ (account) => account.type === AccountType.SERVICE_ACCOUNT
+ ),
+ [visibleSpecialAccounts]
+ );
+ const visibleWorkloadIdentities = useMemo(
+ () =>
+ visibleSpecialAccounts.filter(
+ (account) => account.type === AccountType.WORKLOAD_IDENTITY
+ ),
+ [visibleSpecialAccounts]
+ );
const toggle = (fullname: string) => {
if (disabled) return;
- const binding = fullnameToBinding(fullname);
+ const binding = convertFullnameToMember(fullname);
if (selectedFullnames.has(fullname)) {
labelCacheRef.current.delete(binding);
onChange(value.filter((v) => v !== binding));
@@ -295,19 +452,21 @@ export function AccountMultiSelect({
const group = groups.find((g) => g.name === fullname);
return group?.title || fullname;
}
+ const specialAccount = specialAccounts.find(
+ (account) => account.fullname === fullname
+ );
+ if (specialAccount) {
+ return specialAccount.title || specialAccount.email;
+ }
return undefined;
};
// Detect service account / workload identity typed in search
- const specialAccountMatch = useMemo((): {
- type: SpecialAccountType;
- email: string;
- fullname: string;
- } | null => {
+ const specialAccountMatch = useMemo((): SpecialAccount | null => {
const match = detectSpecialAccount(search);
if (!match || !match.email) return null;
const prefix =
- match.type === "serviceAccount"
+ match.type === AccountType.SERVICE_ACCOUNT
? serviceAccountNamePrefix
: workloadIdentityNamePrefix;
return { ...match, fullname: `${prefix}${match.email}` };
@@ -327,7 +486,11 @@ export function AccountMultiSelect({
}, [search, specialAccountMatch, users]);
const visibleSpecialAccountMatch =
- specialAccountMatch && !excludedFullnames.has(specialAccountMatch.fullname)
+ specialAccountMatch &&
+ !excludedFullnames.has(specialAccountMatch.fullname) &&
+ !visibleSpecialAccounts.some(
+ (account) => account.fullname === specialAccountMatch.fullname
+ )
? specialAccountMatch
: null;
const visibleArbitraryEmailMatch =
@@ -335,6 +498,7 @@ export function AccountMultiSelect({
!excludedFullnames.has(`users/${arbitraryEmailMatch}`)
? arbitraryEmailMatch
: null;
+ const showAllUsers = includeAllUsers && !search.trim();
// Label for a selected binding chip — uses cache to survive search changes
const chipLabel = (binding: string): string => {
@@ -343,11 +507,13 @@ export function AccountMultiSelect({
}
const cached = labelCacheRef.current.get(binding);
if (cached) return cached;
- const fullname = bindingToFullname(binding);
- if (fullname.startsWith("serviceAccounts/"))
- return fullname.slice("serviceAccounts/".length);
- if (fullname.startsWith("workloadIdentities/"))
- return fullname.slice("workloadIdentities/".length);
+ const fullname = convertMemberToFullname(binding);
+ const specialAccount = detectSpecialAccount(fullname);
+ switch (specialAccount?.type) {
+ case AccountType.SERVICE_ACCOUNT:
+ case AccountType.WORKLOAD_IDENTITY:
+ return specialAccount.email;
+ }
return resolveLabel(fullname) || binding;
};
@@ -426,7 +592,7 @@ export function AccountMultiSelect({
<div className="overflow-auto" role="listbox" aria-multiselectable>
{/* allUsers option */}
- {includeAllUsers && (
+ {showAllUsers && (
<div
className={cn(
"flex items-center gap-x-3 px-3 py-2 cursor-pointer hover:bg-control-bg",
@@ -566,8 +732,45 @@ export function AccountMultiSelect({
</div>
)}
- {/* Service account / workload identity match */}
- {visibleSpecialAccountMatch && (
+ {/* Service accounts */}
+ {(visibleSpecialAccountMatch?.type ===
+ AccountType.SERVICE_ACCOUNT ||
+ visibleServiceAccounts.length > 0) && (
+ <div className="px-3 py-1.5 text-xs font-medium text-control-light uppercase tracking-wide bg-control-bg border-b">
+ {t("settings.members.service-accounts")}
+ </div>
+ )}
+ {visibleSpecialAccountMatch?.type ===
+ AccountType.SERVICE_ACCOUNT && (
+ <SpecialAccountOption
+ keyword={search}
+ match={visibleSpecialAccountMatch}
+ selected={selectedFullnames.has(
+ visibleSpecialAccountMatch.fullname
+ )}
+ onToggle={() => toggle(visibleSpecialAccountMatch.fullname)}
+ />
+ )}
+ {visibleServiceAccounts.map((account) => (
+ <SpecialAccountOption
+ key={account.fullname}
+ keyword={search}
+ match={account}
+ selected={selectedFullnames.has(account.fullname)}
+ onToggle={() => toggle(account.fullname)}
+ />
+ ))}
+
+ {/* Workload identities */}
+ {(visibleSpecialAccountMatch?.type ===
+ AccountType.WORKLOAD_IDENTITY ||
+ visibleWorkloadIdentities.length > 0) && (
+ <div className="px-3 py-1.5 text-xs font-medium text-control-light uppercase tracking-wide bg-control-bg border-b">
+ {t("settings.members.workload-identities")}
+ </div>
+ )}
+ {visibleSpecialAccountMatch?.type ===
+ AccountType.WORKLOAD_IDENTITY && (
<SpecialAccountOption
keyword={search}
match={visibleSpecialAccountMatch}
@@ -577,6 +780,15 @@ export function AccountMultiSelect({
onToggle={() => toggle(visibleSpecialAccountMatch.fullname)}
/>
)}
+ {visibleWorkloadIdentities.map((account) => (
+ <SpecialAccountOption
+ key={account.fullname}
+ keyword={search}
+ match={account}
+ selected={selectedFullnames.has(account.fullname)}
+ onToggle={() => toggle(account.fullname)}
+ />
+ ))}
{/* Arbitrary email fallback */}
{visibleArbitraryEmailMatch && (
@@ -613,9 +825,10 @@ export function AccountMultiSelect({
)}
{/* Empty state */}
- {!includeAllUsers &&
+ {!showAllUsers &&
visibleUsers.length === 0 &&
visibleGroups.length === 0 &&
+ visibleSpecialAccounts.length === 0 &&
!visibleSpecialAccountMatch &&
!visibleArbitraryEmailMatch && (
<div className="px-3 py-4 text-sm text-center text-control-light">
diff --git a/frontend/src/routes/workspace/MembersPage.test.tsx b/frontend/src/routes/workspace/MembersPage.test.tsx
index 3e632a91f9..98912e63d0 100644
--- a/frontend/src/routes/workspace/MembersPage.test.tsx
+++ b/frontend/src/routes/workspace/MembersPage.test.tsx
@@ -17,28 +17,34 @@ const {
mockUpdateProjectIamPolicy,
maximumRoleExpirationSeconds,
maximumRequestExpirationSeconds,
+ accountSelectProps,
} = vi.hoisted(() => ({
mockUseProductIntro: vi.fn(),
mockPushNotification: vi.fn(),
mockUpdateProjectIamPolicy: vi.fn(),
maximumRoleExpirationSeconds: { value: undefined as number | undefined },
maximumRequestExpirationSeconds: { value: undefined as number | undefined },
+ accountSelectProps: { value: undefined as { accountParents?: string[] } | undefined },
}));
vi.mock("@/components/AccountMultiSelect", () => ({
AccountMultiSelect: ({
onChange,
+ accountParents,
}: {
onChange: (members: string[]) => void;
- }) =>
- createElement(
+ accountParents?: string[];
+ }) => {
+ accountSelectProps.value = { accountParents };
+ return createElement(
"button",
{
"data-testid": "account-select",
onClick: () => onChange(["user:[email protected]"]),
},
"select account"
- ),
+ );
+ },
}));
vi.mock("@/components/DatabaseResourceSelector", () => ({
@@ -321,6 +327,7 @@ vi.mock("@/stores/app", () => {
}),
// Migrated off the Pinia actuator/setting/subscription store mocks.
isSaaSMode: () => false,
+ workspaceResourceName: () => "workspaces/default",
userCountInIam: () => 1,
userCountLimit: () => 10,
hasFeature: () => true,
@@ -367,6 +374,7 @@ beforeEach(() => {
vi.clearAllMocks();
maximumRoleExpirationSeconds.value = undefined;
maximumRequestExpirationSeconds.value = undefined;
+ accountSelectProps.value = undefined;
projectIamPolicy.bindings = [];
container = document.createElement("div");
document.body.appendChild(container);
@@ -402,6 +410,23 @@ async function flush(): Promise<void> {
}
describe("MembersPage project role grant drawer", () => {
+ it("provides workspace and project parents to the account selector", async () => {
+ await renderPage();
+
+ const grantButton = [...container.querySelectorAll("button")].find(
+ (button) => button.textContent === "settings.members.grant-access"
+ ) as HTMLButtonElement;
+ await act(async () => {
+ grantButton.click();
+ });
+ await flush();
+
+ expect(accountSelectProps.value?.accountParents).toEqual([
+ "workspaces/default",
+ "projects/sample-project",
+ ]);
+ });
+
it("uses maximum role expiration instead of request expiration for direct role grants", async () => {
maximumRequestExpirationSeconds.value = 30 * 24 * 60 * 60;
diff --git a/frontend/src/routes/workspace/MembersPage.tsx b/frontend/src/routes/workspace/MembersPage.tsx
index 511d23ce44..1a4d3645d2 100644
--- a/frontend/src/routes/workspace/MembersPage.tsx
+++ b/frontend/src/routes/workspace/MembersPage.tsx
@@ -1357,6 +1357,7 @@ function EditMemberRoleDrawer({
(state) => state.updateProjectIamPolicy
);
const isSaaSMode = useAppStore((s) => s.isSaaSMode());
+ const workspaceResourceName = useAppStore((s) => s.workspaceResourceName());
const roleList = useAppStore((state) => state.roleList);
const settingsByName = useAppStore((s) => s.settingsByName);
const hasEmailSetting = useMemo(
@@ -1372,6 +1373,16 @@ function EditMemberRoleDrawer({
const isEditMode = !!member;
const isProjectCreateMode = !!projectName && !isEditMode;
const isProjectEditMode = !!projectName && isEditMode;
+ const accountParents = useMemo(
+ () => [
+ ...new Set(
+ [workspaceResourceName, projectName].filter(
+ (parent): parent is string => !!parent
+ )
+ ),
+ ],
+ [workspaceResourceName, projectName]
+ );
// Live project role bindings for the member (reactively updated when IAM policy changes).
// Active bindings come first, expired ones last; original order is preserved within each group.
@@ -1950,6 +1961,7 @@ function EditMemberRoleDrawer({
value={selectedBindings}
onChange={setSelectedBindings}
includeAllUsers={!isSaaSMode}
+ accountParents={accountParents}
/>
)}
</FormField>
diff --git a/frontend/src/stores/app/index.test.ts b/frontend/src/stores/app/index.test.ts
index 6c0ba60979..c815f37239 100644
--- a/frontend/src/stores/app/index.test.ts
+++ b/frontend/src/stores/app/index.test.ts
@@ -1958,6 +1958,25 @@ describe("useAppStore", () => {
);
});
+ test("lists service accounts without caching when requested", async () => {
+ mocks.listServiceAccounts.mockResolvedValue({
+ serviceAccounts: [serviceAccountA],
+ nextPageToken: "",
+ });
+ const store = createAppStore();
+
+ await store.getState().listServiceAccounts({
+ parent: "workspaces/default",
+ pageSize: 20,
+ showDeleted: false,
+ skipCache: true,
+ });
+
+ expect(store.getState().serviceAccountsByName).not.toHaveProperty(
+ serviceAccountA.name
+ );
+ });
+
test("marks cached service account deleted after delete", async () => {
mocks.deleteServiceAccount.mockResolvedValue({});
const store = createAppStore();
@@ -1992,6 +2011,25 @@ describe("useAppStore", () => {
).toBe(workloadIdentityA);
});
+ test("lists workload identities without caching when requested", async () => {
+ mocks.listWorkloadIdentities.mockResolvedValue({
+ workloadIdentities: [workloadIdentityA],
+ nextPageToken: "",
+ });
+ const store = createAppStore();
+
+ await store.getState().listWorkloadIdentities({
+ parent: "workspaces/default",
+ pageSize: 20,
+ showDeleted: false,
+ skipCache: true,
+ });
+
+ expect(store.getState().workloadIdentitiesByName).not.toHaveProperty(
+ workloadIdentityA.name
+ );
+ });
+
test("lists identity providers and replaces the identity provider cache", async () => {
mocks.listIdentityProviders.mockResolvedValue({
identityProviders: [identityProviderA],
diff --git a/frontend/src/stores/app/serviceAccount.ts b/frontend/src/stores/app/serviceAccount.ts
index 88d448713f..815cdf12d5 100644
--- a/frontend/src/stores/app/serviceAccount.ts
+++ b/frontend/src/stores/app/serviceAccount.ts
@@ -65,14 +65,16 @@ export const createServiceAccountSlice: AppSliceCreator<ServiceAccountSlice> = (
filter: buildAccountListFilter(params.filter ?? {}),
})
);
- set((state) => ({
- serviceAccountsByName: {
- ...state.serviceAccountsByName,
- ...Object.fromEntries(
- response.serviceAccounts.map((sa) => [sa.name, sa])
- ),
- },
- }));
+ if (!params.skipCache) {
+ set((state) => ({
+ serviceAccountsByName: {
+ ...state.serviceAccountsByName,
+ ...Object.fromEntries(
+ response.serviceAccounts.map((sa) => [sa.name, sa])
+ ),
+ },
+ }));
+ }
return {
serviceAccounts: response.serviceAccounts,
nextPageToken: response.nextPageToken,
diff --git a/frontend/src/stores/app/types.ts b/frontend/src/stores/app/types.ts
index 53823aa38a..66ddf5df15 100644
--- a/frontend/src/stores/app/types.ts
+++ b/frontend/src/stores/app/types.ts
@@ -139,6 +139,7 @@ export type ListServiceAccountsParams = {
pageToken?: string;
showDeleted: boolean;
filter?: AccountFilter;
+ skipCache?: boolean;
};
export type ListWorkloadIdentitiesParams = {
@@ -147,6 +148,7 @@ export type ListWorkloadIdentitiesParams = {
pageToken?: string;
showDeleted: boolean;
filter?: AccountFilter;
+ skipCache?: boolean;
};
export type AccessGrantFilter = {
diff --git a/frontend/src/stores/app/workloadIdentity.ts b/frontend/src/stores/app/workloadIdentity.ts
index bcc79cc66c..627848c61e 100644
--- a/frontend/src/stores/app/workloadIdentity.ts
+++ b/frontend/src/stores/app/workloadIdentity.ts
@@ -57,14 +57,16 @@ export const createWorkloadIdentitySlice: AppSliceCreator<
filter: buildAccountListFilter(params.filter ?? {}),
})
);
- set((state) => ({
- workloadIdentitiesByName: {
- ...state.workloadIdentitiesByName,
- ...Object.fromEntries(
- response.workloadIdentities.map((wi) => [wi.name, wi])
- ),
- },
- }));
+ if (!params.skipCache) {
+ set((state) => ({
+ workloadIdentitiesByName: {
+ ...state.workloadIdentitiesByName,
+ ...Object.fromEntries(
+ response.workloadIdentities.map((wi) => [wi.name, wi])
+ ),
+ },
+ }));
+ }
return {
workloadIdentities: response.workloadIdentities,
nextPageToken: response.nextPageToken,
diff --git a/frontend/src/utils/v1/iam.test.ts b/frontend/src/utils/v1/iam.test.ts
index 3bf0486817..224c6bf99b 100644
--- a/frontend/src/utils/v1/iam.test.ts
+++ b/frontend/src/utils/v1/iam.test.ts
@@ -5,7 +5,11 @@ import {
ExprSchema,
} from "@/types/proto-es/google/api/expr/v1alpha1/syntax_pb";
import type { Binding } from "@/types/proto-es/v1/iam_policy_pb";
-import { bindingScopesResources } from "./iam";
+import {
+ bindingScopesResources,
+ convertFullnameToMember,
+ convertMemberToFullname,
+} from "./iam";
const binding = (expression?: string, parsedExpr?: Expr) =>
({
@@ -88,3 +92,26 @@ describe("bindingScopesResources", () => {
expect(bindingScopesResources(binding("...", mixed))).toBe(true);
});
});
+
+describe("member fullname conversion", () => {
+ test("round-trips supported IAM member identifiers", () => {
+ const members = [
+ "allUsers",
+ "serviceAccount:[email protected]",
+ "workloadIdentity:[email protected]",
+ ];
+
+ expect(members.map(convertMemberToFullname)).toEqual([
+ "users/allUsers",
+ "groups/[email protected]",
+ "serviceAccounts/[email protected]",
+ "workloadIdentities/[email protected]",
+ ]);
+ expect(
+ members.map(convertMemberToFullname).map(convertFullnameToMember)
+ ).toEqual(members);
+ });
+});
diff --git a/frontend/src/utils/v1/iam.ts b/frontend/src/utils/v1/iam.ts
index 8b059f4213..846f70165a 100644
--- a/frontend/src/utils/v1/iam.ts
+++ b/frontend/src/utils/v1/iam.ts
@@ -13,7 +13,13 @@ import {
workloadIdentityNamePrefix,
} from "@/stores/modules/v1/common";
import {
+ AccountType,
ALL_USERS_USER_EMAIL,
+ getAccountTypeByFullname,
+ getGroupEmailInBinding,
+ getServiceAccountNameInBinding,
+ getUserEmailInBinding,
+ getWorkloadIdentityNameInBinding,
groupBindingPrefix,
type QueryPermission,
QueryPermissionQueryAny,
@@ -160,6 +166,28 @@ export const convertMemberToFullname = (member: string) => {
}
};
+export const convertFullnameToMember = (fullname: string) => {
+ if (fullname === ALL_USERS_USER_EMAIL) {
+ return fullname;
+ }
+ if (fullname.startsWith(groupNamePrefix)) {
+ return getGroupEmailInBinding(fullname.slice(groupNamePrefix.length));
+ }
+ switch (getAccountTypeByFullname(fullname)) {
+ case AccountType.SERVICE_ACCOUNT:
+ return getServiceAccountNameInBinding(extractServiceAccountId(fullname));
+ case AccountType.WORKLOAD_IDENTITY:
+ return getWorkloadIdentityNameInBinding(
+ extractWorkloadIdentityId(fullname)
+ );
+ default:
+ if (fullname.startsWith(userNamePrefix)) {
+ return getUserEmailInBinding(fullname.slice(userNamePrefix.length));
+ }
+ return fullname;
+ }
+};
+
// getUserListInBinding will extract users in the IAM policy binding.
// If the binding is group, will conains all members in the group.
// The return value should be the user full name with the prefix: