Skip to content

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

feat(frontend): migrate resource consumers to React app store (phase 1) (#20421)

boojack943038ad7597
diff --git a/docs/superpowers/plans/2026-05-27-react-zustand-resource-phase-1.md b/docs/superpowers/plans/2026-05-27-react-zustand-resource-phase-1.md
new file mode 100644
index 0000000000..cb629fe00f
--- /dev/null
+++ b/docs/superpowers/plans/2026-05-27-react-zustand-resource-phase-1.md
@@ -0,0 +1,2146 @@
+# React Zustand Resource Migration Phase 1 Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Migrate the phase 1 access/account API resources from legacy Pinia stores into React `useAppStore` Zustand slices and switch React consumers to those slices.
+
+**Architecture:** Add one focused Zustand slice per resource under `frontend/src/react/stores/app/`, composed by `createAppStore()`. Keep legacy Pinia stores in place for Vue or not-yet-migrated callers. Migrate React consumers only after the slice behavior is covered by tests.
+
+**Tech Stack:** React, TypeScript, Zustand, Vitest, Connect RPC, proto-es, Pinia compatibility during migration.
+
+---
+
+## File Structure
+
+Create:
+
+- `frontend/src/react/stores/app/group.ts`
+- `frontend/src/react/stores/app/serviceAccount.ts`
+- `frontend/src/react/stores/app/workloadIdentity.ts`
+- `frontend/src/react/stores/app/identityProvider.ts`
+- `frontend/src/react/stores/app/accessGrant.ts`
+
+Modify:
+
+- `frontend/src/react/stores/app/types.ts`
+- `frontend/src/react/stores/app/index.ts`
+- `frontend/src/react/stores/app/index.test.ts`
+- `frontend/src/react/no-legacy-vue-deps.test.ts`
+- React consumers listed in Tasks 7 and 8
+
+Keep unchanged in this phase:
+
+- `frontend/src/store/modules/v1/group.ts`
+- `frontend/src/store/modules/serviceAccount.ts`
+- `frontend/src/store/modules/workloadIdentity.ts`
+- `frontend/src/store/modules/idp.ts`
+- `frontend/src/store/modules/accessGrant.ts`
+
+Legacy stores are deleted only after a later audit confirms no Vue or React consumers remain.
+
+---
+
+### Task 1: Add App Store Type Contracts
+
+**Files:**
+- Modify: `frontend/src/react/stores/app/types.ts`
+
+- [ ] **Step 1: Add imports for phase 1 resource types**
+
+Add these imports near the existing proto resource imports:
+
+```ts
+import type { AccessGrant } from "@/types/proto-es/v1/access_grant_service_pb";
+import type { Group } from "@/types/proto-es/v1/group_service_pb";
+import type { IdentityProvider } from "@/types/proto-es/v1/idp_service_pb";
+import type { ServiceAccount } from "@/types/proto-es/v1/service_account_service_pb";
+import type { WorkloadIdentity } from "@/types/proto-es/v1/workload_identity_service_pb";
+import type { State } from "@/types/proto-es/v1/common_pb";
+```
+
+- [ ] **Step 2: Add shared filter and params types**
+
+Add these types after `ProjectListParams`:
+
+```ts
+export type GroupFilter = {
+ query?: string;
+ project?: string;
+};
+
+export type AccountFilter = {
+ query?: string;
+ state?: State;
+};
+
+export type ListServiceAccountsParams = {
+ parent: string;
+ pageSize: number;
+ pageToken?: string;
+ showDeleted: boolean;
+ filter?: AccountFilter;
+};
+
+export type ListWorkloadIdentitiesParams = {
+ parent: string;
+ pageSize: number;
+ pageToken?: string;
+ showDeleted: boolean;
+ filter?: AccountFilter;
+};
+
+export type AccessGrantFilter = {
+ name?: string;
+ statement?: string;
+ creator?: string;
+ status?: import("@/utils").AccessGrantFilterStatus[];
+ issue?: string;
+ target?: string;
+ createdTsAfter?: number;
+ createdTsBefore?: number;
+};
+
+export type ListAccessGrantsParams = {
+ parent: string;
+ filter?: AccessGrantFilter;
+ pageSize?: number;
+ pageToken?: string;
+ orderBy?: string;
+};
+```
+
+- [ ] **Step 3: Add slice type definitions**
+
+Add these slice definitions after `InstanceRoleSlice`:
+
+```ts
+export type GroupSlice = {
+ groupsByName: Record<string, Group>;
+ groupRequests: Record<string, Promise<Group | undefined>>;
+ groupErrorsByName: Record<string, Error | undefined>;
+ listGroups: (params: {
+ pageSize: number;
+ pageToken?: string;
+ filter?: GroupFilter;
+ }) => Promise<{ groups: Group[]; nextPageToken: string }>;
+ batchFetchGroups: (names: string[]) => Promise<Group[]>;
+ batchGetOrFetchGroups: (names: string[]) => Promise<(Group | undefined)[]>;
+ fetchGroup: (id: string) => Promise<Group | undefined>;
+ getGroupByIdentifier: (id: string) => Group | undefined;
+ createGroup: (group: Group) => Promise<Group>;
+ updateGroup: (group: Group) => Promise<Group>;
+ deleteGroup: (name: string) => Promise<void>;
+};
+
+export type ServiceAccountSlice = {
+ serviceAccountsByName: Record<string, ServiceAccount>;
+ serviceAccountRequests: Record<
+ string,
+ Promise<ServiceAccount | undefined>
+ >;
+ listServiceAccounts: (
+ params: ListServiceAccountsParams
+ ) => Promise<{
+ serviceAccounts: ServiceAccount[];
+ nextPageToken: string;
+ }>;
+ fetchServiceAccount: (
+ name: string,
+ silent?: boolean
+ ) => Promise<ServiceAccount | undefined>;
+ getServiceAccount: (name: string) => ServiceAccount;
+ createServiceAccount: (
+ serviceAccountId: string,
+ serviceAccount: Partial<ServiceAccount>,
+ parent: string
+ ) => Promise<ServiceAccount>;
+ updateServiceAccount: (
+ serviceAccount: Partial<ServiceAccount>,
+ updateMask: { paths: string[] }
+ ) => Promise<ServiceAccount>;
+ deleteServiceAccount: (name: string) => Promise<void>;
+ undeleteServiceAccount: (name: string) => Promise<ServiceAccount>;
+};
+
+export type WorkloadIdentitySlice = {
+ workloadIdentitiesByName: Record<string, WorkloadIdentity>;
+ workloadIdentityRequests: Record<
+ string,
+ Promise<WorkloadIdentity | undefined>
+ >;
+ listWorkloadIdentities: (
+ params: ListWorkloadIdentitiesParams
+ ) => Promise<{
+ workloadIdentities: WorkloadIdentity[];
+ nextPageToken: string;
+ }>;
+ fetchWorkloadIdentity: (
+ name: string,
+ silent?: boolean
+ ) => Promise<WorkloadIdentity | undefined>;
+ getWorkloadIdentity: (name: string) => WorkloadIdentity;
+ createWorkloadIdentity: (
+ workloadIdentityId: string,
+ workloadIdentity: Partial<WorkloadIdentity>,
+ parent: string
+ ) => Promise<WorkloadIdentity>;
+ updateWorkloadIdentity: (
+ workloadIdentity: Partial<WorkloadIdentity>,
+ updateMask: { paths: string[] }
+ ) => Promise<WorkloadIdentity>;
+ deleteWorkloadIdentity: (name: string) => Promise<void>;
+ undeleteWorkloadIdentity: (name: string) => Promise<WorkloadIdentity>;
+};
+
+export type IdentityProviderSlice = {
+ identityProvidersByName: Record<string, IdentityProvider>;
+ identityProviderRequests: Record<
+ string,
+ Promise<IdentityProvider | undefined>
+ >;
+ identityProviderList: () => IdentityProvider[];
+ listIdentityProviders: (parent?: string) => Promise<IdentityProvider[]>;
+ fetchIdentityProvider: (
+ name: string,
+ silent?: boolean
+ ) => Promise<IdentityProvider | undefined>;
+ getIdentityProvider: (name: string) => IdentityProvider | undefined;
+ createIdentityProvider: (
+ identityProvider: IdentityProvider
+ ) => Promise<IdentityProvider>;
+ updateIdentityProvider: (
+ update: Partial<IdentityProvider>
+ ) => Promise<IdentityProvider>;
+ deleteIdentityProvider: (name: string) => Promise<void>;
+};
+
+export type AccessGrantSlice = {
+ accessGrantsByName: Record<string, AccessGrant>;
+ accessGrantRequests: Record<string, Promise<AccessGrant | undefined>>;
+ fetchAccessGrant: (name: string) => Promise<AccessGrant | undefined>;
+ searchMyAccessGrants: (
+ params: ListAccessGrantsParams
+ ) => Promise<{
+ accessGrants: AccessGrant[];
+ nextPageToken: string;
+ }>;
+ listAccessGrants: (
+ params: ListAccessGrantsParams
+ ) => Promise<{
+ accessGrants: AccessGrant[];
+ nextPageToken: string;
+ }>;
+ createAccessGrant: (
+ parent: string,
+ accessGrant: AccessGrant
+ ) => Promise<AccessGrant>;
+ activateAccessGrant: (name: string) => Promise<AccessGrant>;
+ revokeAccessGrant: (name: string) => Promise<AccessGrant>;
+};
+```
+
+- [ ] **Step 4: Extend `AppStoreState`**
+
+Add the five slice types into the `AppStoreState` intersection:
+
+```ts
+ InstanceRoleSlice &
+ GroupSlice &
+ ServiceAccountSlice &
+ WorkloadIdentitySlice &
+ IdentityProviderSlice &
+ AccessGrantSlice &
+ NotificationSlice &
+```
+
+- [ ] **Step 5: Run focused type-check**
+
+Run:
+
+```bash
+pnpm --dir frontend type-check
+```
+
+Expected: Type-check fails because the new slice types are not yet implemented in `createAppStore()`. This is the intended TDD failure.
+
+---
+
+### Task 2: Add Group Slice
+
+**Files:**
+- Create: `frontend/src/react/stores/app/group.ts`
+- Modify: `frontend/src/react/stores/app/index.ts`
+- Test: `frontend/src/react/stores/app/index.test.ts`
+
+- [ ] **Step 1: Add connect mocks and test data**
+
+In `index.test.ts`, extend the hoisted mocks:
+
+```ts
+listGroups: vi.fn(),
+batchGetGroups: vi.fn(),
+getGroup: vi.fn(),
+createGroup: vi.fn(),
+updateGroup: vi.fn(),
+deleteGroup: vi.fn(),
+```
+
+Add the mocked connect client:
+
+```ts
+groupServiceClientConnect: {
+ listGroups: mocks.listGroups,
+ batchGetGroups: mocks.batchGetGroups,
+ getGroup: mocks.getGroup,
+ createGroup: mocks.createGroup,
+ updateGroup: mocks.updateGroup,
+ deleteGroup: mocks.deleteGroup,
+},
+```
+
+Add imports:
+
+```ts
+import { GroupSchema } from "@/types/proto-es/v1/group_service_pb";
+```
+
+Add fixtures after `projectB`:
+
+```ts
+const groupA = createProto(GroupSchema, {
+ name: "groups/[email protected]",
+ email: "[email protected]",
+ title: "DBA",
+});
+
+const groupB = createProto(GroupSchema, {
+ name: "groups/[email protected]",
+ email: "[email protected]",
+ title: "Dev",
+});
+```
+
+- [ ] **Step 2: Add failing group tests**
+
+Add these tests inside `describe("useAppStore", ...)`:
+
+```ts
+test("lists groups and populates the group cache", async () => {
+ mocks.listGroups.mockResolvedValue({
+ groups: [groupA, groupB],
+ nextPageToken: "next",
+ });
+ const store = createAppStore();
+ store.setState({
+ currentUser: user,
+ roles: [createProto(RoleSchema, {
+ name: "roles/group-viewer",
+ permissions: ["bb.groups.list"],
+ })],
+ workspacePolicy: createProto(IamPolicySchema, {
+ bindings: [createProto(BindingSchema, {
+ role: "roles/group-viewer",
+ members: [`user:${user.email}`],
+ })],
+ }),
+ });
+
+ const result = await store.getState().listGroups({ pageSize: 50 });
+
+ expect(result.groups).toEqual([groupA, groupB]);
+ expect(result.nextPageToken).toBe("next");
+ expect(store.getState().groupsByName[groupA.name]).toBe(groupA);
+ expect(store.getState().groupsByName[groupB.name]).toBe(groupB);
+});
+
+test("batchGetOrFetchGroups skips cached groups and preserves order", async () => {
+ mocks.batchGetGroups.mockResolvedValue({ groups: [groupB] });
+ const store = createAppStore();
+ store.setState({ groupsByName: { [groupA.name]: groupA } });
+
+ const result = await store
+ .getState()
+ .batchGetOrFetchGroups([groupA.name, groupB.name, groupA.name]);
+
+ expect(mocks.batchGetGroups).toHaveBeenCalledTimes(1);
+ expect(result).toEqual([groupA, groupB]);
+ expect(store.getState().groupsByName[groupB.name]).toBe(groupB);
+});
+```
+
+Run:
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/stores/app/index.test.ts
+```
+
+Expected: FAIL because `listGroups` and `batchGetOrFetchGroups` are not implemented.
+
+- [ ] **Step 3: Create `group.ts`**
+
+Create the slice with this structure:
+
+```ts
+import { create as createProto } from "@bufbuild/protobuf";
+import { createContextValues } from "@connectrpc/connect";
+import { uniq } from "lodash-es";
+import { groupServiceClientConnect } from "@/connect";
+import { silentContextKey } from "@/connect/context-key";
+import { isValidProjectName } from "@/types";
+import type { Group } from "@/types/proto-es/v1/group_service_pb";
+import {
+ BatchGetGroupsRequestSchema,
+ CreateGroupRequestSchema,
+ DeleteGroupRequestSchema,
+ GetGroupRequestSchema,
+ ListGroupsRequestSchema,
+ UpdateGroupRequestSchema,
+} from "@/types/proto-es/v1/group_service_pb";
+import { extractGroupEmail, groupNamePrefix } from "@/store/modules/v1/common";
+import type { AppSliceCreator, GroupFilter, GroupSlice } from "./types";
+
+export const buildGroupFilter = (params: GroupFilter) => {
+ const filter = [];
+ const search = params.query?.trim()?.toLowerCase();
+ if (search) {
+ filter.push(`(title.contains("${search}") || email.contains("${search}"))`);
+ }
+ if (isValidProjectName(params.project)) {
+ filter.push(`project == "${params.project}"`);
+ }
+ return filter.join(" && ");
+};
+
+export const ensureGroupIdentifier = (id: string) => {
+ const email = extractGroupEmail(id);
+ return `${groupNamePrefix}${email}`;
+};
+
+export const createGroupSlice: AppSliceCreator<GroupSlice> = (set, get) => ({
+ groupsByName: {},
+ groupRequests: {},
+ groupErrorsByName: {},
+
+ listGroups: async ({ pageSize, pageToken, filter }) => {
+ if (!get().hasWorkspacePermission("bb.groups.list")) {
+ return { groups: [], nextPageToken: "" };
+ }
+ const response = await groupServiceClientConnect.listGroups(
+ createProto(ListGroupsRequestSchema, {
+ pageSize,
+ pageToken,
+ filter: buildGroupFilter(filter ?? {}),
+ }),
+ { contextValues: createContextValues().set(silentContextKey, true) }
+ );
+ set((state) => ({
+ groupsByName: {
+ ...state.groupsByName,
+ ...Object.fromEntries(
+ response.groups.map((group) => [group.name, group])
+ ),
+ },
+ }));
+ return {
+ groups: response.groups,
+ nextPageToken: response.nextPageToken,
+ };
+ },
+
+ batchFetchGroups: async (names) => {
+ const validNames = uniq(names).filter(Boolean).map(ensureGroupIdentifier);
+ if (validNames.length === 0) return [];
+ const response = await groupServiceClientConnect.batchGetGroups(
+ createProto(BatchGetGroupsRequestSchema, { names: validNames }),
+ { contextValues: createContextValues().set(silentContextKey, true) }
+ );
+ set((state) => ({
+ groupsByName: {
+ ...state.groupsByName,
+ ...Object.fromEntries(
+ response.groups.map((group) => [group.name, group])
+ ),
+ },
+ }));
+ return response.groups;
+ },
+
+ batchGetOrFetchGroups: async (names) => {
+ const validNames = uniq(names).filter(Boolean).map(ensureGroupIdentifier);
+ const missing = validNames.filter((name) => !get().groupsByName[name]);
+ if (missing.length > 0) {
+ await get().batchFetchGroups(missing);
+ }
+ return validNames.map((name) => get().groupsByName[name]);
+ },
+
+ fetchGroup: async (id) => {
+ if (!get().hasWorkspacePermission("bb.groups.get")) return undefined;
+ const name = ensureGroupIdentifier(id);
+ const existing = get().groupsByName[name];
+ if (existing) return existing;
+ const pending = get().groupRequests[name];
+ if (pending) return pending;
+ const request = groupServiceClientConnect
+ .getGroup(createProto(GetGroupRequestSchema, { name }), {
+ contextValues: createContextValues().set(silentContextKey, true),
+ })
+ .then((group) => {
+ set((state) => {
+ const { [name]: _, ...groupRequests } = state.groupRequests;
+ return {
+ groupsByName: { ...state.groupsByName, [group.name]: group },
+ groupErrorsByName: { ...state.groupErrorsByName, [name]: undefined },
+ groupRequests,
+ };
+ });
+ return group;
+ })
+ .catch((error) => {
+ set((state) => {
+ const { [name]: _, ...groupRequests } = state.groupRequests;
+ return {
+ groupErrorsByName: {
+ ...state.groupErrorsByName,
+ [name]: error instanceof Error ? error : new Error(String(error)),
+ },
+ groupRequests,
+ };
+ });
+ return undefined;
+ });
+ set((state) => ({
+ groupRequests: { ...state.groupRequests, [name]: request },
+ }));
+ return request;
+ },
+
+ getGroupByIdentifier: (id) => get().groupsByName[ensureGroupIdentifier(id)],
+
+ createGroup: async (group) => {
+ const response = await groupServiceClientConnect.createGroup(
+ createProto(CreateGroupRequestSchema, {
+ group,
+ groupEmail: extractGroupEmail(group.name),
+ })
+ );
+ set((state) => ({
+ groupsByName: { ...state.groupsByName, [response.name]: response },
+ }));
+ return response;
+ },
+
+ updateGroup: async (group) => {
+ const response = await groupServiceClientConnect.updateGroup(
+ createProto(UpdateGroupRequestSchema, {
+ group,
+ updateMask: { paths: ["title", "description", "members"] },
+ allowMissing: false,
+ })
+ );
+ set((state) => ({
+ groupsByName: { ...state.groupsByName, [response.name]: response },
+ }));
+ return response;
+ },
+
+ deleteGroup: async (name) => {
+ await groupServiceClientConnect.deleteGroup(
+ createProto(DeleteGroupRequestSchema, { name })
+ );
+ set((state) => {
+ const { [name]: _, ...groupsByName } = state.groupsByName;
+ return { groupsByName };
+ });
+ },
+});
+```
+
+- [ ] **Step 4: Compose the group slice**
+
+In `index.ts`, import and spread the slice:
+
+```ts
+import { createGroupSlice } from "./group";
+```
+
+```ts
+ ...createInstanceRoleSlice(...args),
+ ...createGroupSlice(...args),
+ ...createNotificationSlice(...args),
+```
+
+- [ ] **Step 5: Run group tests**
+
+Run:
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/stores/app/index.test.ts
+pnpm --dir frontend type-check
+```
+
+Expected: PASS for the new group tests. Type-check may still fail if later task type imports are already declared but slices are not implemented; if Task 1 added only Group types so far, it should pass.
+
+- [ ] **Step 6: Commit group slice**
+
+```bash
+git add frontend/src/react/stores/app/types.ts frontend/src/react/stores/app/index.ts frontend/src/react/stores/app/group.ts frontend/src/react/stores/app/index.test.ts
+git commit -m "feat(frontend): add group resource to app store"
+```
+
+---
+
+### Task 3: Add Service Account and Workload Identity Slices
+
+**Files:**
+- Create: `frontend/src/react/stores/app/serviceAccount.ts`
+- Create: `frontend/src/react/stores/app/workloadIdentity.ts`
+- Modify: `frontend/src/react/stores/app/index.ts`
+- Test: `frontend/src/react/stores/app/index.test.ts`
+
+- [ ] **Step 1: Add connect mocks and fixtures**
+
+Extend the hoisted mocks:
+
+```ts
+listServiceAccounts: vi.fn(),
+getServiceAccount: vi.fn(),
+createServiceAccount: vi.fn(),
+updateServiceAccount: vi.fn(),
+deleteServiceAccount: vi.fn(),
+undeleteServiceAccount: vi.fn(),
+listWorkloadIdentities: vi.fn(),
+getWorkloadIdentity: vi.fn(),
+createWorkloadIdentity: vi.fn(),
+updateWorkloadIdentity: vi.fn(),
+deleteWorkloadIdentity: vi.fn(),
+undeleteWorkloadIdentity: vi.fn(),
+```
+
+Add mocked connect clients:
+
+```ts
+serviceAccountServiceClientConnect: {
+ listServiceAccounts: mocks.listServiceAccounts,
+ getServiceAccount: mocks.getServiceAccount,
+ createServiceAccount: mocks.createServiceAccount,
+ updateServiceAccount: mocks.updateServiceAccount,
+ deleteServiceAccount: mocks.deleteServiceAccount,
+ undeleteServiceAccount: mocks.undeleteServiceAccount,
+},
+workloadIdentityServiceClientConnect: {
+ listWorkloadIdentities: mocks.listWorkloadIdentities,
+ getWorkloadIdentity: mocks.getWorkloadIdentity,
+ createWorkloadIdentity: mocks.createWorkloadIdentity,
+ updateWorkloadIdentity: mocks.updateWorkloadIdentity,
+ deleteWorkloadIdentity: mocks.deleteWorkloadIdentity,
+ undeleteWorkloadIdentity: mocks.undeleteWorkloadIdentity,
+},
+```
+
+Add imports:
+
+```ts
+import { ServiceAccountSchema } from "@/types/proto-es/v1/service_account_service_pb";
+import { WorkloadIdentitySchema } from "@/types/proto-es/v1/workload_identity_service_pb";
+```
+
+Add fixtures:
+
+```ts
+const serviceAccountA = createProto(ServiceAccountSchema, {
+ name: "serviceAccounts/[email protected]",
+ email: "[email protected]",
+ title: "Robot",
+ state: State.ACTIVE,
+});
+
+const workloadIdentityA = createProto(WorkloadIdentitySchema, {
+ name: "workloadIdentities/[email protected]",
+ email: "[email protected]",
+ title: "Deploy",
+ state: State.ACTIVE,
+});
+```
+
+- [ ] **Step 2: Add failing account tests**
+
+Add tests:
+
+```ts
+test("lists service accounts and writes them into cache", async () => {
+ mocks.listServiceAccounts.mockResolvedValue({
+ serviceAccounts: [serviceAccountA],
+ nextPageToken: "next-sa",
+ });
+ const store = createAppStore();
+
+ const result = await store.getState().listServiceAccounts({
+ parent: "workspaces/default",
+ pageSize: 20,
+ showDeleted: false,
+ });
+
+ expect(result.serviceAccounts).toEqual([serviceAccountA]);
+ expect(result.nextPageToken).toBe("next-sa");
+ expect(store.getState().serviceAccountsByName[serviceAccountA.name]).toBe(
+ serviceAccountA
+ );
+});
+
+test("marks cached service account deleted after delete", async () => {
+ mocks.deleteServiceAccount.mockResolvedValue({});
+ const store = createAppStore();
+ store.setState({
+ serviceAccountsByName: { [serviceAccountA.name]: serviceAccountA },
+ });
+
+ await store.getState().deleteServiceAccount(serviceAccountA.name);
+
+ expect(
+ store.getState().serviceAccountsByName[serviceAccountA.name].state
+ ).toBe(State.DELETED);
+});
+
+test("lists workload identities and writes them into cache", async () => {
+ mocks.listWorkloadIdentities.mockResolvedValue({
+ workloadIdentities: [workloadIdentityA],
+ nextPageToken: "next-wi",
+ });
+ const store = createAppStore();
+
+ const result = await store.getState().listWorkloadIdentities({
+ parent: "workspaces/default",
+ pageSize: 20,
+ showDeleted: false,
+ });
+
+ expect(result.workloadIdentities).toEqual([workloadIdentityA]);
+ expect(result.nextPageToken).toBe("next-wi");
+ expect(
+ store.getState().workloadIdentitiesByName[workloadIdentityA.name]
+ ).toBe(workloadIdentityA);
+});
+```
+
+Run:
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/stores/app/index.test.ts
+```
+
+Expected: FAIL because the account slices are not implemented.
+
+- [ ] **Step 3: Create `serviceAccount.ts`**
+
+Create the file with this structure:
+
+```ts
+import { create as createProto } from "@bufbuild/protobuf";
+import { createContextValues } from "@connectrpc/connect";
+import { serviceAccountServiceClientConnect } from "@/connect";
+import { silentContextKey } from "@/connect/context-key";
+import { State } from "@/types/proto-es/v1/common_pb";
+import type { ServiceAccount } from "@/types/proto-es/v1/service_account_service_pb";
+import {
+ CreateServiceAccountRequestSchema,
+ DeleteServiceAccountRequestSchema,
+ GetServiceAccountRequestSchema,
+ ListServiceAccountsRequestSchema,
+ ServiceAccountSchema,
+ UndeleteServiceAccountRequestSchema,
+ UpdateServiceAccountRequestSchema,
+} from "@/types/proto-es/v1/service_account_service_pb";
+import { type User, UserSchema } from "@/types/proto-es/v1/user_service_pb";
+import {
+ extractServiceAccountId,
+ serviceAccountNamePrefix,
+} from "@/store/modules/v1/common";
+import type {
+ AccountFilter,
+ AppSliceCreator,
+ ServiceAccountSlice,
+} from "./types";
+
+export const buildAccountListFilter = (params: AccountFilter) => {
+ const filter = [];
+ const search = params.query?.trim()?.toLowerCase();
+ if (search) {
+ filter.push(`(name.contains("${search}") || email.contains("${search}"))`);
+ }
+ if (params.state === State.DELETED) {
+ filter.push(`state == "${State[params.state]}"`);
+ }
+ return filter.join(" && ");
+};
+
+export const ensureServiceAccountFullName = (identifier: string) => {
+ const id = extractServiceAccountId(identifier);
+ return `${serviceAccountNamePrefix}${id}`;
+};
+
+export const serviceAccountToUser = (sa: ServiceAccount): User =>
+ createProto(UserSchema, {
+ name: `users/${sa.email}`,
+ email: sa.email,
+ title: sa.title,
+ state: sa.state,
+ serviceKey: sa.serviceKey,
+ });
+
+export const createServiceAccountSlice: AppSliceCreator<
+ ServiceAccountSlice
+> = (set, get) => ({
+ serviceAccountsByName: {},
+ serviceAccountRequests: {},
+
+ listServiceAccounts: async (params) => {
+ const response =
+ await serviceAccountServiceClientConnect.listServiceAccounts(
+ createProto(ListServiceAccountsRequestSchema, {
+ parent: params.parent,
+ pageSize: params.pageSize,
+ pageToken: params.pageToken,
+ showDeleted: params.showDeleted,
+ filter: buildAccountListFilter(params.filter ?? {}),
+ })
+ );
+ set((state) => ({
+ serviceAccountsByName: {
+ ...state.serviceAccountsByName,
+ ...Object.fromEntries(
+ response.serviceAccounts.map((sa) => [sa.name, sa])
+ ),
+ },
+ }));
+ return {
+ serviceAccounts: response.serviceAccounts,
+ nextPageToken: response.nextPageToken,
+ };
+ },
+
+ fetchServiceAccount: async (name, silent = false) => {
+ const validName = ensureServiceAccountFullName(name);
+ const existing = get().serviceAccountsByName[validName];
+ if (existing) return existing;
+ const pending = get().serviceAccountRequests[validName];
+ if (pending) return pending;
+ const request = serviceAccountServiceClientConnect
+ .getServiceAccount(
+ createProto(GetServiceAccountRequestSchema, { name: validName }),
+ { contextValues: createContextValues().set(silentContextKey, silent) }
+ )
+ .then((sa) => {
+ set((state) => {
+ const { [validName]: _, ...serviceAccountRequests } =
+ state.serviceAccountRequests;
+ return {
+ serviceAccountsByName: {
+ ...state.serviceAccountsByName,
+ [sa.name]: sa,
+ },
+ serviceAccountRequests,
+ };
+ });
+ return sa;
+ })
+ .catch(() => undefined);
+ set((state) => ({
+ serviceAccountRequests: {
+ ...state.serviceAccountRequests,
+ [validName]: request,
+ },
+ }));
+ return request;
+ },
+
+ getServiceAccount: (name) => {
+ const validName = ensureServiceAccountFullName(name);
+ const email = extractServiceAccountId(validName);
+ return (
+ get().serviceAccountsByName[validName] ??
+ createProto(ServiceAccountSchema, {
+ name,
+ email,
+ state: State.ACTIVE,
+ title: email.split("@")[0],
+ })
+ );
+ },
+
+ createServiceAccount: async (serviceAccountId, serviceAccount, parent) => {
+ const sa = await serviceAccountServiceClientConnect.createServiceAccount(
+ createProto(CreateServiceAccountRequestSchema, {
+ parent,
+ serviceAccountId,
+ serviceAccount: createProto(
+ ServiceAccountSchema,
+ serviceAccount as ServiceAccount
+ ),
+ })
+ );
+ set((state) => ({
+ serviceAccountsByName: { ...state.serviceAccountsByName, [sa.name]: sa },
+ }));
+ return sa;
+ },
+
+ updateServiceAccount: async (serviceAccount, updateMask) => {
+ const sa = await serviceAccountServiceClientConnect.updateServiceAccount(
+ createProto(UpdateServiceAccountRequestSchema, {
+ serviceAccount: createProto(
+ ServiceAccountSchema,
+ serviceAccount as ServiceAccount
+ ),
+ updateMask,
+ })
+ );
+ set((state) => ({
+ serviceAccountsByName: { ...state.serviceAccountsByName, [sa.name]: sa },
+ }));
+ return sa;
+ },
+
+ deleteServiceAccount: async (name) => {
+ await serviceAccountServiceClientConnect.deleteServiceAccount(
+ createProto(DeleteServiceAccountRequestSchema, { name })
+ );
+ set((state) => {
+ const cached = state.serviceAccountsByName[name];
+ if (!cached) return {};
+ return {
+ serviceAccountsByName: {
+ ...state.serviceAccountsByName,
+ [name]: { ...cached, state: State.DELETED },
+ },
+ };
+ });
+ },
+
+ undeleteServiceAccount: async (name) => {
+ const sa = await serviceAccountServiceClientConnect.undeleteServiceAccount(
+ createProto(UndeleteServiceAccountRequestSchema, { name })
+ );
+ set((state) => ({
+ serviceAccountsByName: { ...state.serviceAccountsByName, [sa.name]: sa },
+ }));
+ return sa;
+ },
+});
+```
+
+- [ ] **Step 4: Create `workloadIdentity.ts`**
+
+Create the workload identity slice by following `serviceAccount.ts` with these substitutions:
+
+```ts
+import { workloadIdentityServiceClientConnect } from "@/connect";
+import type { WorkloadIdentity } from "@/types/proto-es/v1/workload_identity_service_pb";
+import {
+ CreateWorkloadIdentityRequestSchema,
+ DeleteWorkloadIdentityRequestSchema,
+ GetWorkloadIdentityRequestSchema,
+ ListWorkloadIdentitiesRequestSchema,
+ UndeleteWorkloadIdentityRequestSchema,
+ UpdateWorkloadIdentityRequestSchema,
+ WorkloadIdentitySchema,
+} from "@/types/proto-es/v1/workload_identity_service_pb";
+import {
+ extractWorkloadIdentityId,
+ workloadIdentityNamePrefix,
+} from "@/store/modules/v1/common";
+import { buildAccountListFilter } from "./serviceAccount";
+import type { AppSliceCreator, WorkloadIdentitySlice } from "./types";
+```
+
+Use these helper and conversion functions:
+
+```ts
+export const ensureWorkloadIdentityFullName = (identifier: string) => {
+ const id = extractWorkloadIdentityId(identifier);
+ return `${workloadIdentityNamePrefix}${id}`;
+};
+
+export const workloadIdentityToUser = (wi: WorkloadIdentity): User =>
+ createProto(UserSchema, {
+ name: `users/${wi.email}`,
+ email: wi.email,
+ title: wi.title,
+ state: wi.state,
+ });
+```
+
+The action names and cache keys must match `WorkloadIdentitySlice` from Task 1:
+
+```ts
+workloadIdentitiesByName
+workloadIdentityRequests
+listWorkloadIdentities
+fetchWorkloadIdentity
+getWorkloadIdentity
+createWorkloadIdentity
+updateWorkloadIdentity
+deleteWorkloadIdentity
+undeleteWorkloadIdentity
+```
+
+Use the same delete behavior as service accounts: if a cached resource exists,
+replace it with a copy whose `state` is `State.DELETED`.
+
+- [ ] **Step 5: Compose account slices**
+
+In `index.ts`:
+
+```ts
+import { createServiceAccountSlice } from "./serviceAccount";
+import { createWorkloadIdentitySlice } from "./workloadIdentity";
+```
+
+Add to `createAppStore()` after `createGroupSlice`:
+
+```ts
+ ...createServiceAccountSlice(...args),
+ ...createWorkloadIdentitySlice(...args),
+```
+
+- [ ] **Step 6: Run account tests**
+
+Run:
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/stores/app/index.test.ts
+pnpm --dir frontend type-check
+```
+
+Expected: PASS.
+
+- [ ] **Step 7: Commit account slices**
+
+```bash
+git add frontend/src/react/stores/app/types.ts frontend/src/react/stores/app/index.ts frontend/src/react/stores/app/serviceAccount.ts frontend/src/react/stores/app/workloadIdentity.ts frontend/src/react/stores/app/index.test.ts
+git commit -m "feat(frontend): add account resources to app store"
+```
+
+---
+
+### Task 4: Add Identity Provider Slice
+
+**Files:**
+- Create: `frontend/src/react/stores/app/identityProvider.ts`
+- Modify: `frontend/src/react/stores/app/index.ts`
+- Test: `frontend/src/react/stores/app/index.test.ts`
+
+- [ ] **Step 1: Add IDP mocks and fixture**
+
+Extend mocks:
+
+```ts
+listIdentityProviders: vi.fn(),
+getIdentityProvider: vi.fn(),
+createIdentityProvider: vi.fn(),
+updateIdentityProvider: vi.fn(),
+deleteIdentityProvider: vi.fn(),
+```
+
+Add connect client:
+
+```ts
+identityProviderServiceClientConnect: {
+ listIdentityProviders: mocks.listIdentityProviders,
+ getIdentityProvider: mocks.getIdentityProvider,
+ createIdentityProvider: mocks.createIdentityProvider,
+ updateIdentityProvider: mocks.updateIdentityProvider,
+ deleteIdentityProvider: mocks.deleteIdentityProvider,
+},
+```
+
+Add import and fixture:
+
+```ts
+import { IdentityProviderSchema } from "@/types/proto-es/v1/idp_service_pb";
+
+const identityProviderA = createProto(IdentityProviderSchema, {
+ name: "idps/google",
+ title: "Google",
+ domain: "example.com",
+});
+```
+
+- [ ] **Step 2: Add failing IDP tests**
+
+```ts
+test("lists identity providers and replaces the identity provider cache", async () => {
+ mocks.listIdentityProviders.mockResolvedValue({
+ identityProviders: [identityProviderA],
+ });
+ const store = createAppStore();
+ store.setState({
+ identityProvidersByName: {
+ "idps/stale": createProto(IdentityProviderSchema, {
+ name: "idps/stale",
+ }),
+ },
+ });
+
+ const providers = await store.getState().listIdentityProviders();
+
+ expect(providers).toEqual([identityProviderA]);
+ expect(store.getState().identityProviderList()).toEqual([identityProviderA]);
+ expect(store.getState().identityProvidersByName).toEqual({
+ [identityProviderA.name]: identityProviderA,
+ });
+});
+
+test("updates identity provider with a field mask based on changed fields", async () => {
+ mocks.getIdentityProvider.mockResolvedValue(identityProviderA);
+ mocks.updateIdentityProvider.mockResolvedValue({
+ ...identityProviderA,
+ title: "Google Workspace",
+ });
+ const store = createAppStore();
+
+ const updated = await store.getState().updateIdentityProvider({
+ name: identityProviderA.name,
+ title: "Google Workspace",
+ });
+
+ expect(updated.title).toBe("Google Workspace");
+ expect(mocks.updateIdentityProvider).toHaveBeenCalledWith(
+ expect.objectContaining({
+ updateMask: { paths: ["title"] },
+ })
+ );
+});
+```
+
+Run:
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/stores/app/index.test.ts
+```
+
+Expected: FAIL because the IDP slice is not implemented.
+
+- [ ] **Step 3: Create `identityProvider.ts`**
+
+Create the slice:
+
+```ts
+import { clone, create as createProto } from "@bufbuild/protobuf";
+import { createContextValues } from "@connectrpc/connect";
+import { isEqual, isUndefined } from "lodash-es";
+import { identityProviderServiceClientConnect } from "@/connect";
+import { silentContextKey } from "@/connect/context-key";
+import type { IdentityProvider } from "@/types/proto-es/v1/idp_service_pb";
+import {
+ CreateIdentityProviderRequestSchema,
+ DeleteIdentityProviderRequestSchema,
+ GetIdentityProviderRequestSchema,
+ IdentityProviderSchema,
+ ListIdentityProvidersRequestSchema,
+ UpdateIdentityProviderRequestSchema,
+} from "@/types/proto-es/v1/idp_service_pb";
+import type { AppSliceCreator, IdentityProviderSlice } from "./types";
+
+const getUpdateMaskFromIdentityProvider = (
+ origin: IdentityProvider,
+ update: Partial<IdentityProvider>
+): string[] => {
+ const updateMask: string[] = [];
+ if (!isUndefined(update.title) && !isEqual(origin.title, update.title)) {
+ updateMask.push("title");
+ }
+ if (!isUndefined(update.domain) && !isEqual(origin.domain, update.domain)) {
+ updateMask.push("domain");
+ }
+ if (!isUndefined(update.config) && !isEqual(origin.config, update.config)) {
+ updateMask.push("config");
+ }
+ return updateMask;
+};
+
+export const createIdentityProviderSlice: AppSliceCreator<
+ IdentityProviderSlice
+> = (set, get) => ({
+ identityProvidersByName: {},
+ identityProviderRequests: {},
+
+ identityProviderList: () =>
+ Object.values(get().identityProvidersByName),
+
+ listIdentityProviders: async (parent) => {
+ const response =
+ await identityProviderServiceClientConnect.listIdentityProviders(
+ createProto(ListIdentityProvidersRequestSchema, {
+ parent: parent ?? "",
+ })
+ );
+ set({
+ identityProvidersByName: Object.fromEntries(
+ response.identityProviders.map((idp) => [idp.name, idp])
+ ),
+ });
+ return response.identityProviders;
+ },
+
+ fetchIdentityProvider: async (name, silent = false) => {
+ const existing = get().identityProvidersByName[name];
+ if (existing) return existing;
+ const pending = get().identityProviderRequests[name];
+ if (pending) return pending;
+ const request = identityProviderServiceClientConnect
+ .getIdentityProvider(
+ createProto(GetIdentityProviderRequestSchema, { name }),
+ { contextValues: createContextValues().set(silentContextKey, silent) }
+ )
+ .then((idp) => {
+ set((state) => {
+ const { [name]: _, ...identityProviderRequests } =
+ state.identityProviderRequests;
+ return {
+ identityProvidersByName: {
+ ...state.identityProvidersByName,
+ [idp.name]: idp,
+ },
+ identityProviderRequests,
+ };
+ });
+ return idp;
+ })
+ .catch(() => undefined);
+ set((state) => ({
+ identityProviderRequests: {
+ ...state.identityProviderRequests,
+ [name]: request,
+ },
+ }));
+ return request;
+ },
+
+ getIdentityProvider: (name) => get().identityProvidersByName[name],
+
+ createIdentityProvider: async (identityProvider) => {
+ const idp =
+ await identityProviderServiceClientConnect.createIdentityProvider(
+ createProto(CreateIdentityProviderRequestSchema, {
+ identityProvider,
+ identityProviderId: identityProvider.name,
+ })
+ );
+ set((state) => ({
+ identityProvidersByName: {
+ ...state.identityProvidersByName,
+ [idp.name]: idp,
+ },
+ }));
+ return idp;
+ },
+
+ updateIdentityProvider: async (update) => {
+ const origin = await get().fetchIdentityProvider(update.name || "");
+ if (!origin) {
+ throw new Error(`identity provider with name ${update.name} not found`);
+ }
+ const fullProvider = clone(IdentityProviderSchema, origin);
+ if (update.title !== undefined) fullProvider.title = update.title;
+ if (update.domain !== undefined) fullProvider.domain = update.domain;
+ if (update.type !== undefined) fullProvider.type = update.type;
+ if (update.config !== undefined) fullProvider.config = update.config;
+ const idp =
+ await identityProviderServiceClientConnect.updateIdentityProvider(
+ createProto(UpdateIdentityProviderRequestSchema, {
+ identityProvider: fullProvider,
+ updateMask: {
+ paths: getUpdateMaskFromIdentityProvider(origin, update),
+ },
+ })
+ );
+ set((state) => ({
+ identityProvidersByName: {
+ ...state.identityProvidersByName,
+ [idp.name]: idp,
+ },
+ }));
+ return idp;
+ },
+
+ deleteIdentityProvider: async (name) => {
+ await identityProviderServiceClientConnect.deleteIdentityProvider(
+ createProto(DeleteIdentityProviderRequestSchema, { name })
+ );
+ set((state) => {
+ const { [name]: _, ...identityProvidersByName } =
+ state.identityProvidersByName;
+ return { identityProvidersByName };
+ });
+ },
+});
+```
+
+- [ ] **Step 4: Compose IDP slice**
+
+In `index.ts`:
+
+```ts
+import { createIdentityProviderSlice } from "./identityProvider";
+```
+
+Add to `createAppStore()`:
+
+```ts
+ ...createIdentityProviderSlice(...args),
+```
+
+- [ ] **Step 5: Run IDP tests**
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/stores/app/index.test.ts
+pnpm --dir frontend type-check
+```
+
+Expected: PASS.
+
+- [ ] **Step 6: Commit IDP slice**
+
+```bash
+git add frontend/src/react/stores/app/types.ts frontend/src/react/stores/app/index.ts frontend/src/react/stores/app/identityProvider.ts frontend/src/react/stores/app/index.test.ts
+git commit -m "feat(frontend): add identity provider resource to app store"
+```
+
+---
+
+### Task 5: Add Access Grant Slice
+
+**Files:**
+- Create: `frontend/src/react/stores/app/accessGrant.ts`
+- Modify: `frontend/src/react/stores/app/index.ts`
+- Test: `frontend/src/react/stores/app/index.test.ts`
+
+- [ ] **Step 1: Add access grant mocks and fixture**
+
+Extend mocks:
+
+```ts
+getAccessGrant: vi.fn(),
+searchMyAccessGrants: vi.fn(),
+createAccessGrant: vi.fn(),
+listAccessGrants: vi.fn(),
+activateAccessGrant: vi.fn(),
+revokeAccessGrant: vi.fn(),
+```
+
+Add connect client:
+
+```ts
+accessGrantServiceClientConnect: {
+ getAccessGrant: mocks.getAccessGrant,
+ searchMyAccessGrants: mocks.searchMyAccessGrants,
+ createAccessGrant: mocks.createAccessGrant,
+ listAccessGrants: mocks.listAccessGrants,
+ activateAccessGrant: mocks.activateAccessGrant,
+ revokeAccessGrant: mocks.revokeAccessGrant,
+},
+```
+
+Add import and fixture:
+
+```ts
+import {
+ AccessGrantSchema,
+ AccessGrant_Status,
+} from "@/types/proto-es/v1/access_grant_service_pb";
+
+const accessGrantA = createProto(AccessGrantSchema, {
+ name: "projects/a/accessGrants/ag1",
+ title: "Query prod",
+ status: AccessGrant_Status.ACTIVE,
+});
+```
+
+- [ ] **Step 2: Add failing access grant tests**
+
+```ts
+test("lists access grants and writes them into cache", async () => {
+ mocks.listAccessGrants.mockResolvedValue({
+ accessGrants: [accessGrantA],
+ nextPageToken: "next-ag",
+ });
+ const store = createAppStore();
+
+ const result = await store.getState().listAccessGrants({
+ parent: "projects/a",
+ pageSize: 20,
+ filter: { status: ["ACTIVE"] },
+ });
+
+ expect(result.accessGrants).toEqual([accessGrantA]);
+ expect(result.nextPageToken).toBe("next-ag");
+ expect(store.getState().accessGrantsByName[accessGrantA.name]).toBe(
+ accessGrantA
+ );
+});
+
+test("revokeAccessGrant writes returned grant into cache", async () => {
+ const revoked = {
+ ...accessGrantA,
+ status: AccessGrant_Status.REVOKED,
+ };
+ mocks.revokeAccessGrant.mockResolvedValue(revoked);
+ const store = createAppStore();
+
+ const result = await store.getState().revokeAccessGrant(accessGrantA.name);
+
+ expect(result).toBe(revoked);
+ expect(store.getState().accessGrantsByName[accessGrantA.name]).toBe(revoked);
+});
+```
+
+Run:
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/stores/app/index.test.ts
+```
+
+Expected: FAIL because the access grant slice is not implemented.
+
+- [ ] **Step 3: Create `accessGrant.ts`**
+
+Create the slice:
+
+```ts
+import { create as createProto } from "@bufbuild/protobuf";
+import { accessGrantServiceClientConnect } from "@/connect";
+import type { AccessGrant } from "@/types/proto-es/v1/access_grant_service_pb";
+import {
+ AccessGrant_Status,
+ ActivateAccessGrantRequestSchema,
+ CreateAccessGrantRequestSchema,
+ GetAccessGrantRequestSchema,
+ ListAccessGrantsRequestSchema,
+ RevokeAccessGrantRequestSchema,
+ SearchMyAccessGrantsRequestSchema,
+} from "@/types/proto-es/v1/access_grant_service_pb";
+import type {
+ AccessGrantFilter,
+ AccessGrantSlice,
+ AppSliceCreator,
+ ListAccessGrantsParams,
+} from "./types";
+
+export const buildAccessGrantFilter = (
+ filter: AccessGrantFilter | undefined,
+ now = new Date()
+): string => {
+ if (!filter) return "";
+ const parts: string[] = [];
+ if (filter.name) parts.push(`name == "${filter.name}"`);
+ if (filter.status !== undefined && filter.status.length > 0) {
+ const statusFilter: string[] = [];
+ for (const status of filter.status) {
+ switch (status) {
+ case "ACTIVE":
+ statusFilter.push(
+ `(status == "${AccessGrant_Status[AccessGrant_Status.ACTIVE]}" && expire_time > "${now.toISOString()}")`
+ );
+ break;
+ case "EXPIRED":
+ statusFilter.push(`expire_time <= "${now.toISOString()}"`);
+ break;
+ default:
+ statusFilter.push(
+ `status == "${status as keyof typeof AccessGrant_Status}"`
+ );
+ }
+ }
+ parts.push(`(${statusFilter.join(" || ")})`);
+ }
+ if (filter.statement) {
+ parts.push(`query.contains("${filter.statement.trim()}")`);
+ }
+ if (filter.creator) parts.push(`creator == "${filter.creator}"`);
+ if (filter.issue) parts.push(`issue == "${filter.issue}"`);
+ if (filter.target) parts.push(`target == "${filter.target}"`);
+ if (filter.createdTsAfter !== undefined) {
+ parts.push(
+ `create_time >= "${new Date(filter.createdTsAfter).toISOString()}"`
+ );
+ }
+ if (filter.createdTsBefore !== undefined) {
+ parts.push(
+ `create_time <= "${new Date(filter.createdTsBefore).toISOString()}"`
+ );
+ }
+ return parts.join(" && ");
+};
+
+const upsertAccessGrants = (
+ set: Parameters<AppSliceCreator<AccessGrantSlice>>[0],
+ accessGrants: AccessGrant[]
+) => {
+ set((state) => ({
+ accessGrantsByName: {
+ ...state.accessGrantsByName,
+ ...Object.fromEntries(accessGrants.map((grant) => [grant.name, grant])),
+ },
+ }));
+};
+
+export const createAccessGrantSlice: AppSliceCreator<AccessGrantSlice> = (
+ set,
+ get
+) => ({
+ accessGrantsByName: {},
+ accessGrantRequests: {},
+
+ fetchAccessGrant: async (name) => {
+ const existing = get().accessGrantsByName[name];
+ if (existing) return existing;
+ const pending = get().accessGrantRequests[name];
+ if (pending) return pending;
+ const request = accessGrantServiceClientConnect
+ .getAccessGrant(createProto(GetAccessGrantRequestSchema, { name }))
+ .then((grant) => {
+ set((state) => {
+ const { [name]: _, ...accessGrantRequests } =
+ state.accessGrantRequests;
+ return {
+ accessGrantsByName: {
+ ...state.accessGrantsByName,
+ [grant.name]: grant,
+ },
+ accessGrantRequests,
+ };
+ });
+ return grant;
+ })
+ .catch(() => undefined);
+ set((state) => ({
+ accessGrantRequests: { ...state.accessGrantRequests, [name]: request },
+ }));
+ return request;
+ },
+
+ searchMyAccessGrants: async (params) => {
+ const response =
+ await accessGrantServiceClientConnect.searchMyAccessGrants(
+ createAccessGrantListRequest(SearchMyAccessGrantsRequestSchema, params)
+ );
+ upsertAccessGrants(set, response.accessGrants);
+ return {
+ accessGrants: response.accessGrants,
+ nextPageToken: response.nextPageToken,
+ };
+ },
+
+ listAccessGrants: async (params) => {
+ const response = await accessGrantServiceClientConnect.listAccessGrants(
+ createAccessGrantListRequest(ListAccessGrantsRequestSchema, params)
+ );
+ upsertAccessGrants(set, response.accessGrants);
+ return {
+ accessGrants: response.accessGrants,
+ nextPageToken: response.nextPageToken,
+ };
+ },
+
+ createAccessGrant: async (parent, accessGrant) => {
+ const grant = await accessGrantServiceClientConnect.createAccessGrant(
+ createProto(CreateAccessGrantRequestSchema, { parent, accessGrant })
+ );
+ upsertAccessGrants(set, [grant]);
+ return grant;
+ },
+
+ activateAccessGrant: async (name) => {
+ const grant = await accessGrantServiceClientConnect.activateAccessGrant(
+ createProto(ActivateAccessGrantRequestSchema, { name })
+ );
+ upsertAccessGrants(set, [grant]);
+ return grant;
+ },
+
+ revokeAccessGrant: async (name) => {
+ const grant = await accessGrantServiceClientConnect.revokeAccessGrant(
+ createProto(RevokeAccessGrantRequestSchema, { name })
+ );
+ upsertAccessGrants(set, [grant]);
+ return grant;
+ },
+});
+
+function createAccessGrantListRequest<T>(
+ schema: T,
+ params: ListAccessGrantsParams
+) {
+ return createProto(schema as never, {
+ parent: params.parent,
+ filter: buildAccessGrantFilter(params.filter),
+ pageSize: params.pageSize ?? 0,
+ pageToken: params.pageToken ?? "",
+ orderBy: params.orderBy ?? "",
+ } as never);
+}
+```
+
+If TypeScript rejects the generic helper because `createProto()` needs a concrete schema type, replace `createAccessGrantListRequest()` with two explicit request constructions, one for `SearchMyAccessGrantsRequestSchema` and one for `ListAccessGrantsRequestSchema`.
+
+- [ ] **Step 4: Compose access grant slice**
+
+In `index.ts`:
+
+```ts
+import { createAccessGrantSlice } from "./accessGrant";
+```
+
+Add to `createAppStore()`:
+
+```ts
+ ...createAccessGrantSlice(...args),
+```
+
+- [ ] **Step 5: Run access grant tests**
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/stores/app/index.test.ts
+pnpm --dir frontend type-check
+```
+
+Expected: PASS. If the generic request helper fails type-check, apply the explicit-request fallback described in Step 3 and rerun.
+
+- [ ] **Step 6: Commit access grant slice**
+
+```bash
+git add frontend/src/react/stores/app/types.ts frontend/src/react/stores/app/index.ts frontend/src/react/stores/app/accessGrant.ts frontend/src/react/stores/app/index.test.ts
+git commit -m "feat(frontend): add access grant resource to app store"
+```
+
+---
+
+### Task 6: Add React Hook Facades for Migrated Resources
+
+**Files:**
+- Modify: `frontend/src/react/hooks/useAppState.ts`
+
+- [ ] **Step 1: Add resource hooks**
+
+Add these exports near the existing project/instance resource hooks:
+
+```ts
+export function useGroups() {
+ const groupsByName = useAppStore((state) => state.groupsByName);
+ return Object.values(groupsByName).sort((a, b) =>
+ a.name.localeCompare(b.name)
+ );
+}
+
+export function useGroupByIdentifier(id: string) {
+ return useAppStore((state) => state.getGroupByIdentifier(id));
+}
+
+export function useServiceAccount(name: string) {
+ return useAppStore((state) => state.getServiceAccount(name));
+}
+
+export function useWorkloadIdentity(name: string) {
+ return useAppStore((state) => state.getWorkloadIdentity(name));
+}
+
+export function useIdentityProviderList() {
+ return useAppStore((state) => state.identityProviderList());
+}
+
+export function useIdentityProvider(name: string) {
+ return useAppStore((state) => state.identityProvidersByName[name]);
+}
+
+export function useAccessGrant(name: string) {
+ return useAppStore((state) => state.accessGrantsByName[name]);
+}
+```
+
+- [ ] **Step 2: Run type-check**
+
+```bash
+pnpm --dir frontend type-check
+```
+
+Expected: PASS.
+
+- [ ] **Step 3: Commit hooks**
+
+```bash
+git add frontend/src/react/hooks/useAppState.ts
+git commit -m "feat(frontend): expose phase one app resource hooks"
+```
+
+---
+
+### Task 7: Migrate Settings and Account React Consumers
+
+**Files:**
+- Modify: `frontend/src/react/pages/settings/GroupsPage.tsx`
+- Modify: `frontend/src/react/pages/settings/UsersPage.tsx`
+- Modify: `frontend/src/react/pages/settings/ServiceAccountsPage.tsx`
+- Modify: `frontend/src/react/pages/settings/WorkloadIdentitiesPage.tsx`
+- Modify: `frontend/src/react/components/AccountMultiSelect.tsx`
+- Modify: `frontend/src/react/components/CreateWorkloadIdentitySheet.tsx`
+
+- [ ] **Step 1: Replace store imports**
+
+Replace imports from `@/store` or `@/store/modules/...` for these symbols:
+
+```ts
+useGroupStore
+useServiceAccountStore
+useWorkloadIdentityStore
+```
+
+Use:
+
+```ts
+import { useAppStore } from "@/react/stores/app";
+```
+
+If a file only needs conversion helpers, import those helpers directly from the new app slice:
+
+```ts
+import {
+ serviceAccountToUser,
+} from "@/react/stores/app/serviceAccount";
+import {
+ workloadIdentityToUser,
+} from "@/react/stores/app/workloadIdentity";
+```
+
+- [ ] **Step 2: Convert component-local store reads**
+
+Convert this pattern:
+
+```ts
+const groupStore = useGroupStore();
+```
+
+to selector-based actions:
+
+```ts
+const listGroups = useAppStore((state) => state.listGroups);
+const createGroup = useAppStore((state) => state.createGroup);
+const updateGroup = useAppStore((state) => state.updateGroup);
+const deleteGroup = useAppStore((state) => state.deleteGroup);
+const groups = useAppStore((state) =>
+ Object.values(state.groupsByName).sort((a, b) => a.name.localeCompare(b.name))
+);
+```
+
+Convert service account actions:
+
+```ts
+const listServiceAccounts = useAppStore(
+ (state) => state.listServiceAccounts
+);
+const createServiceAccount = useAppStore(
+ (state) => state.createServiceAccount
+);
+const updateServiceAccount = useAppStore(
+ (state) => state.updateServiceAccount
+);
+const deleteServiceAccount = useAppStore(
+ (state) => state.deleteServiceAccount
+);
+const undeleteServiceAccount = useAppStore(
+ (state) => state.undeleteServiceAccount
+);
+```
+
+Convert workload identity actions:
+
+```ts
+const listWorkloadIdentities = useAppStore(
+ (state) => state.listWorkloadIdentities
+);
+const createWorkloadIdentity = useAppStore(
+ (state) => state.createWorkloadIdentity
+);
+const updateWorkloadIdentity = useAppStore(
+ (state) => state.updateWorkloadIdentity
+);
+const deleteWorkloadIdentity = useAppStore(
+ (state) => state.deleteWorkloadIdentity
+);
+const undeleteWorkloadIdentity = useAppStore(
+ (state) => state.undeleteWorkloadIdentity
+);
+```
+
+- [ ] **Step 3: Preserve method names at call sites**
+
+When a page currently calls:
+
+```ts
+groupStore.fetchGroupList(params)
+```
+
+replace with:
+
+```ts
+listGroups(params)
+```
+
+When it calls:
+
+```ts
+serviceAccountStore.listServiceAccounts(params)
+workloadIdentityStore.listWorkloadIdentities(params)
+```
+
+keep the same params object and call the selected Zustand action:
+
+```ts
+listServiceAccounts(params)
+listWorkloadIdentities(params)
+```
+
+When it calls:
+
+```ts
+serviceAccountStore.getServiceAccount(name)
+workloadIdentityStore.getWorkloadIdentity(name)
+groupStore.getGroupByIdentifier(name)
+```
+
+use either a selector in render code or `useAppStore.getState()` in non-render utility callbacks:
+
+```ts
+const account = useAppStore((state) => state.getServiceAccount(name));
+```
+
+```ts
+const account = useAppStore.getState().getServiceAccount(name);
+```
+
+- [ ] **Step 4: Run focused type-check**
+
+```bash
+pnpm --dir frontend type-check
+```
+
+Expected: PASS.
+
+- [ ] **Step 5: Run focused tests for touched settings pages**
+
+Run existing tests if present:
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/pages/settings
+pnpm --dir frontend exec vitest run frontend/src/react/components/AccountMultiSelect.test.tsx frontend/src/react/components/CreateWorkloadIdentitySheet.test.tsx
+```
+
+Expected: PASS for existing files. If a listed test file does not exist, rerun `pnpm --dir frontend test` in Task 10 instead of creating unrelated tests in this task.
+
+- [ ] **Step 6: Commit settings/account consumer migration**
+
+```bash
+git add frontend/src/react/pages/settings/GroupsPage.tsx frontend/src/react/pages/settings/UsersPage.tsx frontend/src/react/pages/settings/ServiceAccountsPage.tsx frontend/src/react/pages/settings/WorkloadIdentitiesPage.tsx frontend/src/react/components/AccountMultiSelect.tsx frontend/src/react/components/CreateWorkloadIdentitySheet.tsx
+git commit -m "refactor(frontend): use app store for account resources"
+```
+
+---
+
+### Task 8: Migrate IDP and Access Grant React Consumers
+
+**Files:**
+- Modify: `frontend/src/react/pages/auth/SigninPage.tsx`
+- Modify: `frontend/src/react/pages/settings/IDPsPage.tsx`
+- Modify: `frontend/src/react/pages/settings/IDPDetailPage.tsx`
+- Modify: `frontend/src/react/pages/settings/general/AccountSection.tsx`
+- Modify: `frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx`
+- Modify: `frontend/src/react/pages/project/issue-detail/components/IssueDetailAccessGrantDetails.tsx`
+- Modify: `frontend/src/react/components/sql-editor/AccessPane.tsx`
+
+- [ ] **Step 1: Replace IDP store imports**
+
+Replace:
+
+```ts
+import { useIdentityProviderStore } from "@/store";
+import { useIdentityProviderStore } from "@/store/modules/idp";
+```
+
+with:
+
+```ts
+import { useAppStore } from "@/react/stores/app";
+```
+
+Select actions and state:
+
+```ts
+const identityProviders = useAppStore((state) =>
+ state.identityProviderList()
+);
+const listIdentityProviders = useAppStore(
+ (state) => state.listIdentityProviders
+);
+const fetchIdentityProvider = useAppStore(
+ (state) => state.fetchIdentityProvider
+);
+const createIdentityProvider = useAppStore(
+ (state) => state.createIdentityProvider
+);
+const updateIdentityProvider = useAppStore(
+ (state) => state.updateIdentityProvider
+);
+const deleteIdentityProvider = useAppStore(
+ (state) => state.deleteIdentityProvider
+);
+```
+
+Map old calls:
+
+```ts
+identityProviderStore.fetchIdentityProviderList(parent)
+```
+
+to:
+
+```ts
+listIdentityProviders(parent)
+```
+
+Map:
+
+```ts
+identityProviderStore.patchIdentityProvider(update)
+```
+
+to:
+
+```ts
+updateIdentityProvider(update)
+```
+
+- [ ] **Step 2: Replace access grant store imports**
+
+Replace:
+
+```ts
+import { useAccessGrantStore } from "@/store";
+```
+
+with:
+
+```ts
+import { useAppStore } from "@/react/stores/app";
+```
+
+Select actions:
+
+```ts
+const fetchAccessGrant = useAppStore((state) => state.fetchAccessGrant);
+const searchMyAccessGrants = useAppStore(
+ (state) => state.searchMyAccessGrants
+);
+const listAccessGrants = useAppStore((state) => state.listAccessGrants);
+const createAccessGrant = useAppStore((state) => state.createAccessGrant);
+const activateAccessGrant = useAppStore((state) => state.activateAccessGrant);
+const revokeAccessGrant = useAppStore((state) => state.revokeAccessGrant);
+```
+
+Map old calls:
+
+```ts
+accessGrantStore.getAccessGrant(name)
+```
+
+to:
+
+```ts
+fetchAccessGrant(name)
+```
+
+Map the list/search/create/activate/revoke calls to the same action names on
+`useAppStore`.
+
+- [ ] **Step 3: Run focused type-check**
+
+```bash
+pnpm --dir frontend type-check
+```
+
+Expected: PASS.
+
+- [ ] **Step 4: Run focused tests for touched surfaces**
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/pages/auth/SigninPage.test.tsx frontend/src/react/components/sql-editor/AccessPane.test.tsx
+pnpm --dir frontend exec vitest run frontend/src/react/pages/settings frontend/src/react/pages/project
+```
+
+Expected: PASS for existing tests. If the broad project/settings command is too slow, run the specific test files touched by this task plus full `pnpm --dir frontend test` in Task 10.
+
+- [ ] **Step 5: Commit IDP and access consumer migration**
+
+```bash
+git add frontend/src/react/pages/auth/SigninPage.tsx frontend/src/react/pages/settings/IDPsPage.tsx frontend/src/react/pages/settings/IDPDetailPage.tsx frontend/src/react/pages/settings/general/AccountSection.tsx frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx frontend/src/react/pages/project/issue-detail/components/IssueDetailAccessGrantDetails.tsx frontend/src/react/components/sql-editor/AccessPane.tsx
+git commit -m "refactor(frontend): use app store for idp and access grants"
+```
+
+---
+
+### Task 9: Add No-Legacy Store Guard
+
+**Files:**
+- Modify: `frontend/src/react/no-legacy-vue-deps.test.ts`
+
+- [ ] **Step 1: Add phase 1 resource store guard**
+
+Append this test inside the existing `describe` block:
+
+```ts
+ test("phase one resource consumers do not import migrated Pinia stores", () => {
+ const phaseOneFiles = [
+ "./pages/settings/GroupsPage.tsx",
+ "./pages/settings/UsersPage.tsx",
+ "./pages/settings/ServiceAccountsPage.tsx",
+ "./pages/settings/WorkloadIdentitiesPage.tsx",
+ "./pages/auth/SigninPage.tsx",
+ "./pages/settings/IDPsPage.tsx",
+ "./pages/settings/IDPDetailPage.tsx",
+ "./pages/settings/general/AccountSection.tsx",
+ "./pages/project/ProjectAccessGrantsPage.tsx",
+ "./pages/project/issue-detail/components/IssueDetailAccessGrantDetails.tsx",
+ "./components/sql-editor/AccessPane.tsx",
+ "./components/AccountMultiSelect.tsx",
+ "./components/CreateWorkloadIdentitySheet.tsx",
+ ];
+ const bannedImports = [
+ "useGroupStore",
+ "useServiceAccountStore",
+ "useWorkloadIdentityStore",
+ "useIdentityProviderStore",
+ "useAccessGrantStore",
+ "@/store/modules/v1/group",
+ "@/store/modules/serviceAccount",
+ "@/store/modules/workloadIdentity",
+ "@/store/modules/idp",
+ "@/store/modules/accessGrant",
+ ];
+ const violations: string[] = [];
+ for (const file of phaseOneFiles) {
+ const source = sources[file];
+ if (!source) {
+ violations.push(`${file}: missing from no-legacy source glob`);
+ continue;
+ }
+ for (const bannedImport of bannedImports) {
+ if (source.includes(bannedImport)) {
+ violations.push(`${file}: ${bannedImport}`);
+ }
+ }
+ }
+ expect(violations).toEqual([]);
+ });
+```
+
+If any listed file is not covered by the existing `import.meta.glob`, extend the
+glob at the top of the file to include it.
+
+- [ ] **Step 2: Run the guard**
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/no-legacy-vue-deps.test.ts
+```
+
+Expected: PASS.
+
+- [ ] **Step 3: Commit guard**
+
+```bash
+git add frontend/src/react/no-legacy-vue-deps.test.ts
+git commit -m "test(frontend): guard phase one resource store migration"
+```
+
+---
+
+### Task 10: Full Verification and Cleanup
+
+**Files:**
+- Any files changed by `pnpm --dir frontend fix`
+
+- [ ] **Step 1: Run frontend fix**
+
+```bash
+pnpm --dir frontend fix
+```
+
+Expected: command exits 0. It may format or organize imports.
+
+- [ ] **Step 2: Run frontend static check**
+
+```bash
+pnpm --dir frontend check
+```
+
+Expected: command exits 0.
+
+- [ ] **Step 3: Run React type-check**
+
+```bash
+pnpm --dir frontend type-check
+```
+
+Expected: command exits 0.
+
+- [ ] **Step 4: Run focused store and guard tests**
+
+```bash
+pnpm --dir frontend exec vitest run frontend/src/react/stores/app/index.test.ts frontend/src/react/no-legacy-vue-deps.test.ts
+```
+
+Expected: command exits 0.
+
+- [ ] **Step 5: Run full frontend tests**
+
+```bash
+pnpm --dir frontend test
+```
+
+Expected: command exits 0. Known Vite dynamic-import warnings from SQL Editor store tests may appear; failures must be fixed.
+
+- [ ] **Step 6: Run whitespace check**
+
+```bash
+git diff --check
+```
+
+Expected: command exits 0.
+
+- [ ] **Step 7: Inspect remaining migrated-store imports**
+
+Run:
+
+```bash
+rg -n "use(Group|ServiceAccount|WorkloadIdentity|IdentityProvider|AccessGrant)Store|@/store/modules/(v1/group|serviceAccount|workloadIdentity|idp|accessGrant)" frontend/src/react
+```
+
+Expected: no matches in the phase 1 migrated files. Matches in tests that mock legacy stores or in out-of-scope files must be reviewed individually and documented in the PR description.
+
+- [ ] **Step 8: Commit final fixes**
+
+If `frontend fix` or verification changes files:
+
+```bash
+git add frontend/src
+git commit -m "fix(frontend): clean up phase one resource migration"
+```
+
+If there are no additional changes, do not create an empty commit.
+
+---
+
+## Plan Self-Review
+
+- Spec coverage: This plan implements the five approved resources, switches React consumers, adds no-legacy guards, and leaves Pinia deletion out of scope.
+- Placeholder scan: No implementation task relies on unspecified future work. Where a TypeScript generic helper may not type-check, the fallback is explicit and local to that step.
+- Type consistency: Slice method names match the `types.ts` contracts and the consumer migration mapping.
+- Scope check: `ProjectWebhook`, `AuditLog`, lifecycle resources, governance resources, and database metadata resources are excluded from this phase.
diff --git a/docs/superpowers/specs/2026-05-27-react-zustand-resource-phase-1-design.md b/docs/superpowers/specs/2026-05-27-react-zustand-resource-phase-1-design.md
new file mode 100644
index 0000000000..9da44afb35
--- /dev/null
+++ b/docs/superpowers/specs/2026-05-27-react-zustand-resource-phase-1-design.md
@@ -0,0 +1,386 @@
+# React Zustand Resource Migration Phase 1 Design
+
+## Summary
+
+Migrate the first high-value set of React-used API resources from legacy
+Vue/Pinia stores into the React `useAppStore` Zustand store:
+
+- `Group`
+- `ServiceAccount`
+- `WorkloadIdentity`
+- `IdentityProvider`
+- `AccessGrant`
+
+This phase targets resources that already have React consumers but still import
+Pinia stores directly. The goal is to establish the resource-slice pattern and
+remove the most common access/account Pinia dependencies from React without
+forcing a full store migration.
+
+## Motivation
+
+The React application already uses `useAppStore` for core resources such as
+workspace, project, instance, database, sheet, IAM, and subscription state.
+Several React pages still depend on legacy Pinia stores for access/account
+resources:
+
+- Settings pages: users, groups, service accounts, workload identities, IDPs.
+- Auth pages: sign-in and account settings IDP reads.
+- Project access surfaces: access grants and SQL Editor access panes.
+- Shared account utilities and selectors used by React components.
+
+Keeping those imports in React makes migration progress uneven and keeps the
+React tree coupled to Vue reactivity. Phase 1 moves the most actively used
+access/account resources into Zustand while leaving legacy Pinia stores in place
+for any Vue or not-yet-migrated consumers.
+
+## Scope
+
+### In Scope
+
+Add React app-store slices for:
+
+1. `Group`
+2. `ServiceAccount`
+3. `WorkloadIdentity`
+4. `IdentityProvider`
+5. `AccessGrant`
+
+Switch React consumers of those stores to `useAppStore` where the behavior is
+equivalent.
+
+Add tests for cache behavior, request de-duplication, filter construction, and
+mutation cache updates.
+
+Add regression coverage so migrated React surfaces do not re-import these five
+Pinia stores.
+
+### Out of Scope
+
+Do not migrate these resources in phase 1:
+
+- `Issue`
+- `IssueComment`
+- `Plan`
+- `Rollout`
+- `Release`
+- `DatabaseCatalog`
+- `DBSchema`
+- `Policy`
+- `Setting`
+- `WorkspaceApprovalSetting`
+- `SQLReview`
+- `ProjectWebhook`
+- `AuditLog`
+- SQL execution/export helpers
+- AI conversation plugin store
+
+Do not delete the legacy Pinia modules in this phase. Deletion should happen
+only after a follow-up audit confirms no Vue or React consumers remain.
+
+Do not convert unrelated UI, route, or design-system code while migrating the
+store calls.
+
+## Architecture
+
+Use the existing `frontend/src/react/stores/app/` structure. Each migrated
+resource gets its own slice file and type section:
+
+```text
+frontend/src/react/stores/app/
+ accessGrant.ts
+ group.ts
+ identityProvider.ts
+ serviceAccount.ts
+ workloadIdentity.ts
+ types.ts
+ index.ts
+```
+
+`index.ts` composes the new slices into `createAppStore()` alongside existing
+slices.
+
+The store remains a bounded React app store. It does not become a generic API
+client or a global resource framework. Resource-specific behavior stays in the
+resource slice, while only small repeatable utilities may be shared.
+
+## Store Contract
+
+Each resource slice follows the current app-store pattern:
+
+- Store entities in plain records keyed by full resource name.
+- Store in-flight get requests by resource name when the resource supports
+ get-by-name.
+- Return API responses from list/search methods and also upsert returned
+ entities into the cache.
+- Update the cache after successful create/update/undelete operations.
+- Remove or replace cached entries after successful delete/revoke operations
+ according to the API response semantics.
+- Keep pagination tokens in page components, not in the shared store.
+
+React components should use:
+
+- `useAppStore(selector)` for reactive reads.
+- `useAppStore(selector)` for actions used inside components.
+- `useAppStore.getState().action()` only for imperative code outside render
+ subscriptions.
+
+React code must not use `useVueState(() => useAppStore.getState()...)` as a
+subscription bridge.
+
+## Resource Details
+
+### Group
+
+Port behavior from `frontend/src/store/modules/v1/group.ts`.
+
+State:
+
+- `groupsByName: Record<string, Group>`
+- `groupRequests: Record<string, Promise<Group | undefined>>`
+- `groupErrorsByName: Record<string, Error | undefined>`
+
+Actions and helpers:
+
+- `listGroups(params)`
+- `fetchGroup(name, silent?)`
+- `batchFetchGroups(names)`
+- `batchGetOrFetchGroups(names)`
+- `getGroupByIdentifier(id)`
+- `createGroup(group)`
+- `updateGroup(group)`
+- `deleteGroup(name)`
+- `ensureGroupIdentifier(id)`
+- `buildGroupFilter(filter)`
+
+Behavior to preserve:
+
+- Normalize identifiers to `groups/{email}`.
+- Batch fetch unique group names.
+- Keep list results sorted at the selector/consumer level when needed.
+- Preserve permission-sensitive empty-list behavior if the existing caller
+ depends on it.
+
+### ServiceAccount
+
+Port behavior from `frontend/src/store/modules/serviceAccount.ts`.
+
+State:
+
+- `serviceAccountsByName: Record<string, ServiceAccount>`
+- `serviceAccountRequests: Record<string, Promise<ServiceAccount | undefined>>`
+
+Actions and helpers:
+
+- `listServiceAccounts(params)`
+- `fetchServiceAccount(name, silent?)`
+- `getServiceAccount(name)`
+- `createServiceAccount(parent, serviceAccount)`
+- `updateServiceAccount(serviceAccount, updateMask?)`
+- `deleteServiceAccount(name)`
+- `undeleteServiceAccount(name)`
+- `ensureServiceAccountFullName(identifier)`
+- `buildAccountListFilter(filter)`
+
+Behavior to preserve:
+
+- Return a stable fallback object from `getServiceAccount()` for unknown names.
+- Normalize identifiers before cache lookup.
+- Update cache after create, update, and undelete.
+- Mark deleted service accounts according to the API response or remove cache
+ entries only when the API does not return a usable updated resource.
+
+### WorkloadIdentity
+
+Port behavior from `frontend/src/store/modules/workloadIdentity.ts`.
+
+State:
+
+- `workloadIdentitiesByName: Record<string, WorkloadIdentity>`
+- `workloadIdentityRequests: Record<string, Promise<WorkloadIdentity | undefined>>`
+
+Actions and helpers:
+
+- `listWorkloadIdentities(params)`
+- `fetchWorkloadIdentity(name, silent?)`
+- `getWorkloadIdentity(name)`
+- `createWorkloadIdentity(parent, workloadIdentity)`
+- `updateWorkloadIdentity(workloadIdentity, updateMask?)`
+- `deleteWorkloadIdentity(name)`
+- `undeleteWorkloadIdentity(name)`
+- `ensureWorkloadIdentityFullName(identifier)`
+
+Behavior to preserve:
+
+- Reuse the account-list filter shape shared with service accounts.
+- Return a stable fallback user-shaped object where existing React account
+ utilities expect one.
+- Preserve subject-pattern parsing and form behavior in UI code; the store only
+ owns API resource state.
+
+### IdentityProvider
+
+Port behavior from `frontend/src/store/modules/idp.ts`.
+
+State:
+
+- `identityProvidersByName: Record<string, IdentityProvider>`
+- `identityProviderList: IdentityProvider[]` or a selector over
+ `identityProvidersByName`
+- `identityProviderRequests: Record<string, Promise<IdentityProvider | undefined>>`
+
+Actions:
+
+- `listIdentityProviders(parent?)`
+- `fetchIdentityProvider(name, silent?)`
+- `getIdentityProvider(name)`
+- `createIdentityProvider(identityProvider)`
+- `updateIdentityProvider(identityProvider, updateMask?)`
+- `deleteIdentityProvider(name)`
+
+Behavior to preserve:
+
+- Listing replaces the known list for IDP pages while also populating by-name
+ cache.
+- Patch/update should preserve existing field-mask semantics.
+- Delete removes the cached provider after success.
+- Sign-in page reads must stay reactive so IDP buttons update after the list
+ load completes.
+
+### AccessGrant
+
+Port behavior from `frontend/src/store/modules/accessGrant.ts`.
+
+State:
+
+- `accessGrantsByName: Record<string, AccessGrant>`
+- `accessGrantRequests: Record<string, Promise<AccessGrant | undefined>>`
+
+Actions and helpers:
+
+- `fetchAccessGrant(name)`
+- `searchMyAccessGrants(params)`
+- `listAccessGrants(params)`
+- `createAccessGrant(parent, accessGrant)`
+- `activateAccessGrant(name)`
+- `revokeAccessGrant(name)`
+- `buildAccessGrantFilter(filter)`
+
+Behavior to preserve:
+
+- Preserve ACTIVE versus EXPIRED filter semantics based on `expire_time`.
+- Upsert search/list/get results into cache.
+- Update cache after create/activate/revoke based on returned resources.
+- Keep page-level pagination outside the shared store.
+
+## Consumer Migration
+
+Switch React consumers in this order:
+
+1. Settings/member pages:
+ - `frontend/src/react/pages/settings/GroupsPage.tsx`
+ - `frontend/src/react/pages/settings/UsersPage.tsx`
+ - `frontend/src/react/pages/settings/ServiceAccountsPage.tsx`
+ - `frontend/src/react/pages/settings/WorkloadIdentitiesPage.tsx`
+2. IDP surfaces:
+ - `frontend/src/react/pages/auth/SigninPage.tsx`
+ - `frontend/src/react/pages/settings/IDPsPage.tsx`
+ - `frontend/src/react/pages/settings/IDPDetailPage.tsx`
+ - `frontend/src/react/pages/settings/general/AccountSection.tsx`
+3. Access-grant surfaces:
+ - `frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx`
+ - `frontend/src/react/pages/project/issue-detail/components/IssueDetailAccessGrantDetails.tsx`
+ - `frontend/src/react/components/sql-editor/AccessPane.tsx`
+4. Shared account components and helpers:
+ - `frontend/src/react/components/AccountMultiSelect.tsx`
+ - `frontend/src/react/components/CreateWorkloadIdentitySheet.tsx`
+ - React-used member/IAM helper paths that currently read these Pinia stores.
+
+If a shared utility is used by both Vue and React, avoid forcing it to depend on
+`useAppStore`. Prefer either a React-specific helper or a small pure helper that
+accepts resource lookup functions as arguments.
+
+## Testing Strategy
+
+### Store Tests
+
+Extend `frontend/src/react/stores/app/index.test.ts` unless the file becomes too
+large. If it becomes hard to read, split tests by slice while keeping the same
+mock style.
+
+Required coverage:
+
+- Slice is composed into `createAppStore()`.
+- Get-by-name request de-duplication.
+- List/search upserts returned resources into cache.
+- Create/update/undelete writes returned resource into cache.
+- Delete/revoke updates cache consistently.
+- Filter builder output for meaningful combinations.
+- Name normalizers handle full resource names and bare identifiers.
+
+### React Import Guard
+
+Add or extend no-legacy tests so migrated React files do not import:
+
+- `useGroupStore`
+- `useServiceAccountStore`
+- `useWorkloadIdentityStore`
+- `useIdentityProviderStore`
+- `useAccessGrantStore`
+
+The guard should target only files migrated in phase 1 so unrelated legacy
+surfaces do not block the PR.
+
+### Verification Commands
+
+Run:
+
+```bash
+pnpm --dir frontend fix
+pnpm --dir frontend check
+pnpm --dir frontend type-check
+pnpm --dir frontend exec vitest run frontend/src/react/stores/app/index.test.ts
+pnpm --dir frontend test
+git diff --check
+```
+
+If CI static checks fail while local checks pass, reproduce with:
+
+```bash
+pnpm --dir frontend exec eslint src --no-cache
+```
+
+## Rollout Strategy
+
+Use multiple focused PRs if implementation gets large:
+
+1. Store slices and tests.
+2. Settings/member consumer migration.
+3. IDP consumer migration.
+4. Access-grant consumer migration.
+5. Shared helper cleanup and no-legacy guards.
+
+Do not delete Pinia stores until a later cleanup confirms no Vue or React
+consumers remain.
+
+## Risks
+
+- Shared utilities imported by both Vue and React may accidentally become
+ coupled to `useAppStore`. Keep shared utilities pure or split React-specific
+ wrappers.
+- IDP list behavior affects sign-in. The sign-in page must remain reactive after
+ async list loading.
+- Service account and workload identity stores return fallback user-shaped
+ resources today. Preserve this where account selectors rely on it.
+- Access grant filters include time-sensitive ACTIVE/EXPIRED logic. Test these
+ filters with fixed time inputs or deterministic assertions.
+- A broad consumer migration can touch many React pages. Keep each PR narrowly
+ staged if review size grows.
+
+## Success Criteria
+
+- The five phase 1 resources are available through `useAppStore`.
+- Migrated React consumers no longer import the five legacy Pinia stores.
+- Existing behavior for list/get/create/update/delete flows remains unchanged.
+- Store tests cover cache, request, mutation, and filter behavior.
+- Frontend fix, check, type-check, focused tests, full tests, and `git diff
+ --check` pass before implementation is considered complete.
diff --git a/frontend/src/react/components/AccountMultiSelect.tsx b/frontend/src/react/components/AccountMultiSelect.tsx
index 33aabb31bd..dfd4600f21 100644
--- a/frontend/src/react/components/AccountMultiSelect.tsx
+++ b/frontend/src/react/components/AccountMultiSelect.tsx
@@ -6,7 +6,8 @@ import { SearchInput } from "@/react/components/ui/search-input";
import { useClickOutside } from "@/react/hooks/useClickOutside";
import { useVueState } from "@/react/hooks/useVueState";
import { cn } from "@/react/lib/utils";
-import { useCurrentUserV1, useGroupStore, useUserStore } from "@/store";
+import { useAppStore } from "@/react/stores/app";
+import { useCurrentUserV1, useUserStore } from "@/store";
import {
extractUserEmail,
groupNamePrefix,
@@ -192,7 +193,7 @@ export function AccountMultiSelect({
}) {
const { t } = useTranslation();
const userStore = useUserStore();
- const groupStore = useGroupStore();
+ const listGroups = useAppStore((state) => state.listGroups);
const currentUser = useVueState(() => useCurrentUserV1().value);
const [open, setOpen] = useState(false);
@@ -214,14 +215,14 @@ export function AccountMultiSelect({
userStore
.fetchUserList({ pageSize: getDefaultPagination(), filter: { query } })
.then(({ users: fetched }) => setUsers(fetched));
- groupStore
- .fetchGroupList({ pageSize: getDefaultPagination(), filter: { query } })
- .then(({ groups: fetched }) => setGroups(fetched));
+ listGroups({ pageSize: getDefaultPagination(), filter: { query } }).then(
+ ({ groups: fetched }) => setGroups(fetched)
+ );
}, 300);
return () => {
if (debounceRef.current) clearTimeout(debounceRef.current);
};
- }, [search, userStore, groupStore]);
+ }, [search, userStore, listGroups]);
const handleClickOutside = useCallback(() => {
setOpen(false);
diff --git a/frontend/src/react/components/CreateWorkloadIdentitySheet.tsx b/frontend/src/react/components/CreateWorkloadIdentitySheet.tsx
index 52a04ea56e..9636aaa52e 100644
--- a/frontend/src/react/components/CreateWorkloadIdentitySheet.tsx
+++ b/frontend/src/react/components/CreateWorkloadIdentitySheet.tsx
@@ -15,15 +15,15 @@ import {
SheetTitle,
} from "@/react/components/ui/sheet";
import { useVueState } from "@/react/hooks/useVueState";
+import { useAppStore } from "@/react/stores/app";
+import { ensureWorkloadIdentityFullName } from "@/react/stores/app/workloadIdentity";
import {
- ensureWorkloadIdentityFullName,
pushNotification,
useActuatorV1Store,
useProjectV1Store,
useWorkspaceV1Store,
} from "@/store";
import { useProjectIamPolicyStore } from "@/store/modules/v1/projectIamPolicy";
-import { useWorkloadIdentityStore } from "@/store/modules/workloadIdentity";
import {
getWorkloadIdentityNameInBinding,
getWorkloadIdentitySuffix,
@@ -134,11 +134,16 @@ function WorkloadIdentityForm({
onUpdated,
}: Omit<CreateWorkloadIdentitySheetProps, "open">) {
const { t } = useTranslation();
- const workloadIdentityStore = useWorkloadIdentityStore();
const workspaceStore = useWorkspaceV1Store();
const actuatorStore = useActuatorV1Store();
const projectStore = useProjectV1Store();
const projectIamPolicyStore = useProjectIamPolicyStore();
+ const createWorkloadIdentity = useAppStore(
+ (state) => state.createWorkloadIdentity
+ );
+ const updateWorkloadIdentity = useAppStore(
+ (state) => state.updateWorkloadIdentity
+ );
const projectEntity = useVueState(() =>
project ? projectStore.getProjectByName(project) : undefined
@@ -347,7 +352,7 @@ function WorkloadIdentityForm({
};
const handleCreate = async () => {
- const wi = await workloadIdentityStore.createWorkloadIdentity(
+ const wi = await createWorkloadIdentity(
emailPrefix,
{
title: title || emailPrefix,
@@ -391,7 +396,7 @@ function WorkloadIdentityForm({
updateMask.push("title");
}
- const updated = await workloadIdentityStore.updateWorkloadIdentity(
+ const updated = await updateWorkloadIdentity(
create(WorkloadIdentitySchema, {
name: ensureWorkloadIdentityFullName(workloadIdentity.email),
title,
diff --git a/frontend/src/react/components/sql-editor/AccessPane.test.tsx b/frontend/src/react/components/sql-editor/AccessPane.test.tsx
index b61cadc9cd..a07f5a2b8a 100644
--- a/frontend/src/react/components/sql-editor/AccessPane.test.tsx
+++ b/frontend/src/react/components/sql-editor/AccessPane.test.tsx
@@ -19,7 +19,7 @@ const mocks = vi.hoisted(() => ({
highlightAccessGrantName: undefined as string | undefined,
},
setHighlightAccessGrantName: vi.fn(),
- useAccessGrantStore: vi.fn(),
+ searchMyAccessGrants: vi.fn(),
useIssueV1Store: vi.fn(),
useDatabaseV1Store: vi.fn(),
hasFeature: vi.fn(() => true),
@@ -37,12 +37,18 @@ vi.mock("@/react/hooks/useVueState", () => ({
vi.mock("@/store", () => ({
useProjectV1Store: mocks.useProjectV1Store,
- useAccessGrantStore: mocks.useAccessGrantStore,
useIssueV1Store: mocks.useIssueV1Store,
useDatabaseV1Store: mocks.useDatabaseV1Store,
hasFeature: mocks.hasFeature,
}));
+vi.mock("@/react/stores/app", () => ({
+ useAppStore: (selector: (state: unknown) => unknown) =>
+ selector({
+ searchMyAccessGrants: mocks.searchMyAccessGrants,
+ }),
+}));
+
vi.mock("@/react/stores/sqlEditor/tab-vue-state", () => ({
useSQLEditorTabStore: mocks.useSQLEditorTabStore,
}));
@@ -72,8 +78,6 @@ vi.mock("@/react/stores/sqlEditor", () => ({
),
}));
-vi.mock("@/store/modules/accessGrant", () => ({}));
-
vi.mock("@/utils", () => ({
getDefaultPagination: mocks.getDefaultPagination,
}));
@@ -244,11 +248,9 @@ const setupDefaultMocks = () => {
mocks.state.highlightAccessGrantName = undefined;
- mocks.useAccessGrantStore.mockReturnValue({
- searchMyAccessGrants: vi.fn().mockResolvedValue({
- accessGrants: [],
- nextPageToken: "",
- }),
+ mocks.searchMyAccessGrants.mockResolvedValue({
+ accessGrants: [],
+ nextPageToken: "",
});
mocks.useIssueV1Store.mockReturnValue({
@@ -293,14 +295,12 @@ describe("AccessPane", () => {
test("loading state — shows spinner while loading", async () => {
let resolveSearch: (val: unknown) => void = () => {};
- mocks.useAccessGrantStore.mockReturnValue({
- searchMyAccessGrants: vi.fn(
- () =>
- new Promise((resolve) => {
- resolveSearch = resolve;
- })
- ),
- });
+ mocks.searchMyAccessGrants.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ resolveSearch = resolve;
+ })
+ );
const { container, render, unmount } = renderIntoContainer(<AccessPane />);
render();
@@ -321,11 +321,9 @@ describe("AccessPane", () => {
test("renders grants list when populated", async () => {
const grants = [makeGrant("grant1"), makeGrant("grant2")];
- mocks.useAccessGrantStore.mockReturnValue({
- searchMyAccessGrants: vi.fn().mockResolvedValue({
- accessGrants: grants,
- nextPageToken: "",
- }),
+ mocks.searchMyAccessGrants.mockResolvedValue({
+ accessGrants: grants,
+ nextPageToken: "",
});
mocks.useVueState.mockImplementation((getter: () => unknown) => getter());
@@ -380,11 +378,9 @@ describe("AccessPane", () => {
test("click Run on a grant → emits execute-sql event", async () => {
const grant = makeGrant("grant1");
- mocks.useAccessGrantStore.mockReturnValue({
- searchMyAccessGrants: vi.fn().mockResolvedValue({
- accessGrants: [grant],
- nextPageToken: "",
- }),
+ mocks.searchMyAccessGrants.mockResolvedValue({
+ accessGrants: [grant],
+ nextPageToken: "",
});
mocks.useVueState.mockImplementation((getter: () => unknown) => getter());
diff --git a/frontend/src/react/components/sql-editor/AccessPane.tsx b/frontend/src/react/components/sql-editor/AccessPane.tsx
index 73706d8c13..419ece7854 100644
--- a/frontend/src/react/components/sql-editor/AccessPane.tsx
+++ b/frontend/src/react/components/sql-editor/AccessPane.tsx
@@ -17,16 +17,16 @@ import { FeatureBadge } from "@/react/components/FeatureBadge";
import { PermissionGuard } from "@/react/components/PermissionGuard";
import { Button } from "@/react/components/ui/button";
import { useVueState } from "@/react/hooks/useVueState";
+import { useAppStore } from "@/react/stores/app";
+import type { AccessGrantFilter as AccessFilter } from "@/react/stores/app/types";
import { useSQLEditorStore } from "@/react/stores/sqlEditor";
import { useSQLEditorVueState } from "@/react/stores/sqlEditor/editor-vue-state";
import {
hasFeature,
- useAccessGrantStore,
useDatabaseV1Store,
useIssueV1Store,
useProjectV1Store,
} from "@/store";
-import type { AccessFilter } from "@/store/modules/accessGrant";
import type { AccessGrant } from "@/types/proto-es/v1/access_grant_service_pb";
import { AccessGrant_Status } from "@/types/proto-es/v1/access_grant_service_pb";
import type { Issue } from "@/types/proto-es/v1/issue_service_pb";
@@ -49,7 +49,9 @@ export function AccessPane() {
const projectStore = useProjectV1Store();
const editorStore = useSQLEditorVueState();
- const accessGrantStore = useAccessGrantStore();
+ const searchMyAccessGrants = useAppStore(
+ (state) => state.searchMyAccessGrants
+ );
const issueStore = useIssueV1Store();
const databaseStore = useDatabaseV1Store();
const highlightAccessGrantName = useSQLEditorStore(
@@ -198,7 +200,7 @@ export function AccessPane() {
setLoading(true);
try {
- const response = await accessGrantStore.searchMyAccessGrants({
+ const response = await searchMyAccessGrants({
parent,
filter,
pageSize: PAGE_SIZE,
@@ -216,7 +218,7 @@ export function AccessPane() {
setLoading(false);
}
},
- [projectName, filter, accessGrantStore, fetchIssuesForPendingGrants]
+ [projectName, filter, searchMyAccessGrants, fetchIssuesForPendingGrants]
);
// Re-fetch when project or filter changes
diff --git a/frontend/src/react/hooks/useAppState.ts b/frontend/src/react/hooks/useAppState.ts
index c647b5ba48..f99fbe7bf2 100644
--- a/frontend/src/react/hooks/useAppState.ts
+++ b/frontend/src/react/hooks/useAppState.ts
@@ -1,4 +1,5 @@
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useShallow } from "zustand/react/shallow";
import {
getProjectResourceId,
isConnectAlreadyExists,
@@ -264,6 +265,39 @@ export function useInstance(name: string | undefined) {
return instance;
}
+export function useGroups() {
+ const groupsByName = useAppStore((state) => state.groupsByName);
+ return useMemo(
+ () =>
+ Object.values(groupsByName).sort((a, b) => a.name.localeCompare(b.name)),
+ [groupsByName]
+ );
+}
+
+export function useGroupByIdentifier(id: string) {
+ return useAppStore((state) => state.getGroupByIdentifier(id));
+}
+
+export function useServiceAccount(name: string) {
+ return useAppStore(useShallow((state) => state.getServiceAccount(name)));
+}
+
+export function useWorkloadIdentity(name: string) {
+ return useAppStore(useShallow((state) => state.getWorkloadIdentity(name)));
+}
+
+export function useIdentityProviderList() {
+ return useAppStore(useShallow((state) => state.identityProviderList()));
+}
+
+export function useIdentityProvider(name: string) {
+ return useAppStore((state) => state.identityProvidersByName[name]);
+}
+
+export function useAccessGrant(name: string) {
+ return useAppStore((state) => state.accessGrantsByName[name]);
+}
+
export function useProjectList(query: string) {
const searchProjects = useAppStore((state) => state.searchProjects);
const [projects, setProjects] = useState<Project[]>([]);
diff --git a/frontend/src/react/no-legacy-vue-deps.test.ts b/frontend/src/react/no-legacy-vue-deps.test.ts
index d6705df2e5..b16e0b3df9 100644
--- a/frontend/src/react/no-legacy-vue-deps.test.ts
+++ b/frontend/src/react/no-legacy-vue-deps.test.ts
@@ -4,6 +4,8 @@ const sources = import.meta.glob(
[
"./pages/project/**/*.{ts,tsx}",
"./pages/settings/**/*.{ts,tsx}",
+ "./pages/auth/**/*.{ts,tsx}",
+ "./components/**/*.{ts,tsx}",
"../router/dashboard/projectV1.ts",
"../router/dashboard/workspace.ts",
"../router/dashboard/workspaceSetting.ts",
@@ -113,4 +115,27 @@ describe("React Project and Settings legacy Vue dependencies", () => {
}
expect(violations).toEqual([]);
});
+
+ test("Phase 1 protobuf resource consumers use the React app store", () => {
+ const bannedImports = [
+ "useGroupStore",
+ "useServiceAccountStore",
+ "useWorkloadIdentityStore",
+ "useIdentityProviderStore",
+ "useAccessGrantStore",
+ "@/store/modules/serviceAccount",
+ "@/store/modules/workloadIdentity",
+ "@/store/modules/idp",
+ "@/store/modules/accessGrant",
+ ];
+ const violations: string[] = [];
+ for (const [file, source] of Object.entries(sources)) {
+ for (const bannedImport of bannedImports) {
+ if (source.includes(bannedImport)) {
+ violations.push(`${file}: ${bannedImport}`);
+ }
+ }
+ }
+ expect(violations).toEqual([]);
+ });
});
diff --git a/frontend/src/react/pages/auth/SigninPage.test.tsx b/frontend/src/react/pages/auth/SigninPage.test.tsx
index 6abc3acd75..1e7f75d84d 100644
--- a/frontend/src/react/pages/auth/SigninPage.test.tsx
+++ b/frontend/src/react/pages/auth/SigninPage.test.tsx
@@ -17,7 +17,8 @@ const mocks = vi.hoisted(() => ({
pushNotification: vi.fn(),
openWindowForSSO: vi.fn(),
actuatorStore: null as unknown,
- identityProviderStore: null as unknown,
+ identityProviderList: [] as unknown[],
+ listIdentityProviders: vi.fn(),
authStore: null as unknown,
}));
@@ -40,7 +41,22 @@ vi.mock("@/store", () => ({
pushNotification: mocks.pushNotification,
useActuatorV1Store: () => mocks.actuatorStore,
useAuthStore: () => mocks.authStore,
- useIdentityProviderStore: () => mocks.identityProviderStore,
+}));
+
+vi.mock("@/react/stores/app", () => ({
+ useAppStore: Object.assign(
+ (selector: (state: unknown) => unknown) =>
+ selector({
+ identityProviderList: () => mocks.identityProviderList,
+ listIdentityProviders: mocks.listIdentityProviders,
+ }),
+ {
+ getState: () => ({
+ identityProviderList: () => mocks.identityProviderList,
+ listIdentityProviders: mocks.listIdentityProviders,
+ }),
+ }
+ ),
}));
vi.mock("@/utils", () => ({
@@ -103,22 +119,20 @@ beforeEach(async () => {
activeUserCount: 1,
fetchServerInfo: vi.fn(async () => ({})),
};
- mocks.identityProviderStore = {
- identityProviderList: [
- {
- name: "idps/corp-ldap",
- title: "Corp LDAP",
- type: IdentityProviderType.LDAP,
- },
- ],
- fetchIdentityProviderList: vi.fn(async () => [
- {
- name: "idps/corp-ldap",
- title: "Corp LDAP",
- type: IdentityProviderType.LDAP,
- },
- ]),
- };
+ mocks.identityProviderList = [
+ {
+ name: "idps/corp-ldap",
+ title: "Corp LDAP",
+ type: IdentityProviderType.LDAP,
+ },
+ ];
+ mocks.listIdentityProviders.mockResolvedValue([
+ {
+ name: "idps/corp-ldap",
+ title: "Corp LDAP",
+ type: IdentityProviderType.LDAP,
+ },
+ ]);
mocks.authStore = {
login: vi.fn(async () => {}),
};
diff --git a/frontend/src/react/pages/auth/SigninPage.tsx b/frontend/src/react/pages/auth/SigninPage.tsx
index a9e10c91e1..aa9a88617f 100644
--- a/frontend/src/react/pages/auth/SigninPage.tsx
+++ b/frontend/src/react/pages/auth/SigninPage.tsx
@@ -12,15 +12,12 @@ import {
TabsPanel,
TabsTrigger,
} from "@/react/components/ui/tabs";
+import { useIdentityProviderList } from "@/react/hooks/useAppState";
import { useVueState } from "@/react/hooks/useVueState";
+import { useAppStore } from "@/react/stores/app";
import { router } from "@/router";
import { AUTH_SIGNUP_MODULE } from "@/router/auth";
-import {
- pushNotification,
- useActuatorV1Store,
- useAuthStore,
- useIdentityProviderStore,
-} from "@/store";
+import { pushNotification, useActuatorV1Store, useAuthStore } from "@/store";
import { idpNamePrefix } from "@/store/modules/v1/common";
import type { LoginRequest } from "@/types/proto-es/v1/auth_service_pb";
import type { IdentityProvider } from "@/types/proto-es/v1/idp_service_pb";
@@ -52,9 +49,7 @@ export function SigninPage(props: SigninPageProps) {
const activeUserCount = useVueState(
() => useActuatorV1Store().activeUserCount
);
- const identityProviders = useVueState(
- () => useIdentityProviderStore().identityProviderList
- );
+ const identityProviders = useIdentityProviderList();
const query = router.currentRoute.value.query;
const invitedEmail = (query.email as string | undefined) ?? "";
@@ -125,15 +120,16 @@ export function SigninPage(props: SigninPageProps) {
initRef.current = true;
(async () => {
const workspaceName = resolveWorkspaceName();
- const idpStore = useIdentityProviderStore();
+ const listIdentityProviders =
+ useAppStore.getState().listIdentityProviders;
const actuatorStore = useActuatorV1Store();
try {
const [idpList] = await Promise.all([
- idpStore.fetchIdentityProviderList(workspaceName),
+ listIdentityProviders(workspaceName),
actuatorStore.fetchServerInfo(workspaceName),
]);
if (idpList.length === 0 && workspaceName) {
- await idpStore.fetchIdentityProviderList();
+ await listIdentityProviders();
}
} catch (error) {
pushNotification({
@@ -146,9 +142,10 @@ export function SigninPage(props: SigninPageProps) {
const idpQuery = query.idp;
if (idpQuery) {
const name = `${idpNamePrefix}${idpQuery}`;
- const idp = idpStore.identityProviderList.find(
- (i: IdentityProvider) => i.name === name
- );
+ const idp = useAppStore
+ .getState()
+ .identityProviderList()
+ .find((i: IdentityProvider) => i.name === name);
if (idp) {
// On success this navigates away; on failure `trySigninWithIdp`
// pushes a notification and we still need to show the form so the
diff --git a/frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx b/frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx
index 6741d1945b..5dd5b2972b 100644
--- a/frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx
+++ b/frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx
@@ -32,17 +32,17 @@ import {
import { Tooltip } from "@/react/components/ui/tooltip";
import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";
import { useVueState } from "@/react/hooks/useVueState";
+import { useAppStore } from "@/react/stores/app";
+import type { AccessGrantFilter as AccessFilter } from "@/react/stores/app/types";
import { router } from "@/router";
import {
featureToRef,
pushNotification,
- useAccessGrantStore,
useCurrentUserV1,
useDatabaseV1Store,
useProjectV1Store,
useUserStore,
} from "@/store";
-import type { AccessFilter } from "@/store/modules/accessGrant";
import { extractUserEmail, projectNamePrefix } from "@/store/modules/v1/common";
import { getTimeForPbTimestampProtoEs } from "@/types";
import type { AccessGrant } from "@/types/proto-es/v1/access_grant_service_pb";
@@ -112,10 +112,12 @@ function mapDatabase(db: Database) {
export function ProjectAccessGrantsPage({ projectId }: { projectId: string }) {
const { t } = useTranslation();
- const accessGrantStore = useAccessGrantStore();
const projectStore = useProjectV1Store();
const databaseStore = useDatabaseV1Store();
const userStore = useUserStore();
+ const listAccessGrants = useAppStore((state) => state.listAccessGrants);
+ const activateAccessGrant = useAppStore((state) => state.activateAccessGrant);
+ const revokeAccessGrant = useAppStore((state) => state.revokeAccessGrant);
const currentUser = useVueState(() => useCurrentUserV1().value);
const projectName = `${projectNamePrefix}${projectId}`;
@@ -332,7 +334,7 @@ export function ProjectAccessGrantsPage({ projectId }: { projectId: string }) {
filter.createdTsBefore = parseInt(parts[1], 10);
}
}
- const response = await accessGrantStore.listAccessGrants({
+ const response = await listAccessGrants({
parent: projectName,
filter,
pageSize: params.pageSize,
@@ -344,7 +346,7 @@ export function ProjectAccessGrantsPage({ projectId }: { projectId: string }) {
nextPageToken: response.nextPageToken,
};
},
- [projectName, accessGrantStore, searchParams, orderBy]
+ [projectName, listAccessGrants, searchParams, orderBy]
);
const paged = usePagedData<AccessGrant>({
@@ -357,14 +359,14 @@ export function ProjectAccessGrantsPage({ projectId }: { projectId: string }) {
if (!confirmAction) return;
const { type, grant } = confirmAction;
if (type === "activate") {
- await accessGrantStore.activateAccessGrant(grant.name);
+ await activateAccessGrant(grant.name);
pushNotification({
module: "bytebase",
style: "SUCCESS",
title: t("common.activated"),
});
} else {
- await accessGrantStore.revokeAccessGrant(grant.name);
+ await revokeAccessGrant(grant.name);
pushNotification({
module: "bytebase",
style: "SUCCESS",
@@ -373,7 +375,7 @@ export function ProjectAccessGrantsPage({ projectId }: { projectId: string }) {
}
setConfirmAction(null);
paged.refresh();
- }, [confirmAction, accessGrantStore, t, paged]);
+ }, [confirmAction, activateAccessGrant, revokeAccessGrant, t, paged]);
return (
<div className="py-4 w-full flex flex-col">
diff --git a/frontend/src/react/pages/project/ProjectGitOpsPage.tsx b/frontend/src/react/pages/project/ProjectGitOpsPage.tsx
index 49869b47ca..3d0337037f 100644
--- a/frontend/src/react/pages/project/ProjectGitOpsPage.tsx
+++ b/frontend/src/react/pages/project/ProjectGitOpsPage.tsx
@@ -16,17 +16,17 @@ import {
} from "@/react/components/ui/tabs";
import { useVueState } from "@/react/hooks/useVueState";
import { cn } from "@/react/lib/utils";
+import { useAppStore } from "@/react/stores/app";
+import { extractWorkloadIdentityId } from "@/react/stores/app/workloadIdentity";
import { router } from "@/router";
import { SETTING_ROUTE_WORKSPACE_GENERAL } from "@/router/dashboard/workspaceSetting";
import {
- extractWorkloadIdentityId,
useActuatorV1Store,
useDatabaseV1Store,
useProjectV1Store,
} from "@/store";
import { useDBGroupStore } from "@/store/modules/dbGroup";
import { projectNamePrefix } from "@/store/modules/v1/common";
-import { useWorkloadIdentityStore } from "@/store/modules/workloadIdentity";
import { DatabaseGroupView } from "@/types/proto-es/v1/database_group_service_pb";
import type { WorkloadIdentity } from "@/types/proto-es/v1/workload_identity_service_pb";
import { WorkloadIdentityConfig_ProviderType } from "@/types/proto-es/v1/workload_identity_service_pb";
@@ -42,10 +42,15 @@ import {
export function ProjectGitOpsPage({ projectId }: { projectId: string }) {
const { t } = useTranslation();
const actuatorStore = useActuatorV1Store();
- const workloadIdentityStore = useWorkloadIdentityStore();
const dbGroupStore = useDBGroupStore();
const databaseStore = useDatabaseV1Store();
const projectStore = useProjectV1Store();
+ const listWorkloadIdentities = useAppStore(
+ (state) => state.listWorkloadIdentities
+ );
+ const fetchWorkloadIdentity = useAppStore(
+ (state) => state.fetchWorkloadIdentity
+ );
const projectName = `${projectNamePrefix}${projectId}`;
const project = useVueState(() => projectStore.getProjectByName(projectName));
@@ -67,6 +72,11 @@ export function ProjectGitOpsPage({ projectId }: { projectId: string }) {
// Workload identity options
const [wiOptions, setWiOptions] = useState<ComboboxOption[]>([]);
const [wiSearch, setWiSearch] = useState("");
+ const selectedIdentity = useAppStore((state) =>
+ selectedIdentityName
+ ? state.getWorkloadIdentity(selectedIdentityName)
+ : undefined
+ );
const fetchWorkloadIdentities = useCallback(
async (search: string) => {
@@ -74,7 +84,7 @@ export function ProjectGitOpsPage({ projectId }: { projectId: string }) {
let pageToken: string | undefined;
// Fetch all pages so every identity is discoverable.
do {
- const resp = await workloadIdentityStore.listWorkloadIdentities({
+ const resp = await listWorkloadIdentities({
parent: projectName,
filter: { query: search },
pageToken,
@@ -92,7 +102,7 @@ export function ProjectGitOpsPage({ projectId }: { projectId: string }) {
} while (pageToken);
setWiOptions(all);
},
- [projectName, workloadIdentityStore]
+ [projectName, listWorkloadIdentities]
);
useEffect(() => {
@@ -147,16 +157,9 @@ export function ProjectGitOpsPage({ projectId }: { projectId: string }) {
// returns the real object (with workloadIdentityConfig) instead of a stub.
useEffect(() => {
if (selectedIdentityName) {
- workloadIdentityStore
- .getOrFetchWorkloadIdentity(selectedIdentityName)
- .catch(() => {});
+ fetchWorkloadIdentity(selectedIdentityName).catch(() => {});
}
- }, [selectedIdentityName, workloadIdentityStore]);
-
- const selectedIdentity = useVueState(() => {
- if (!selectedIdentityName) return undefined;
- return workloadIdentityStore.getWorkloadIdentity(selectedIdentityName);
- });
+ }, [selectedIdentityName, fetchWorkloadIdentity]);
const selectedConfig = selectedIdentity?.workloadIdentityConfig;
diff --git a/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsx b/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsx
index 0b16367bbd..4e4fb89784 100644
--- a/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsx
+++ b/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsx
@@ -44,16 +44,15 @@ import type {
ExemptionMember,
} from "@/react/lib/sensitive-data/types";
import { cn } from "@/react/lib/utils";
+import { useAppStore } from "@/react/stores/app";
import { router } from "@/router";
import { PROJECT_V1_ROUTE_MASKING_EXEMPTION_CREATE } from "@/router/dashboard/projectV1";
import {
- composePolicyBindings,
extractUserEmail,
hasFeature,
pushNotification,
useCurrentUserV1,
useDatabaseV1Store,
- useGroupStore,
usePolicyV1Store,
useProjectV1Store,
useSettingV1Store,
@@ -598,9 +597,9 @@ function useExemptionDataReact(projectName: string) {
const { t } = useTranslation();
const policyStore = usePolicyV1Store();
const settingStore = useSettingV1Store();
-
- // Ensure group store is initialized for composePolicyBindings
- useGroupStore();
+ const batchGetOrFetchGroups = useAppStore(
+ (state) => state.batchGetOrFetchGroups
+ );
// Ensure classification config is loaded
useEffect(() => {
@@ -646,7 +645,11 @@ function useExemptionDataReact(projectName: string) {
if (generation !== fetchGenRef.current) return;
- await composePolicyBindings(exemptions, true);
+ await batchGetOrFetchGroups(
+ exemptions
+ .flatMap((exemption) => exemption.members)
+ .filter((member) => member.startsWith(groupBindingPrefix))
+ );
const memberMap = new Map<string, AccessUser>();
for (let i = 0; i < exemptions.length; i++) {
@@ -668,7 +671,7 @@ function useExemptionDataReact(projectName: string) {
setLoading(false);
}
}
- }, [projectName, policyStore]);
+ }, [projectName, policyStore, batchGetOrFetchGroups]);
useEffect(() => {
fetchData();
@@ -993,17 +996,17 @@ function ExemptionDetailPanel({
onRevoke: (grant: ExemptionGrant) => void;
}) {
const { t } = useTranslation();
- const groupStore = useGroupStore();
const userEmail = useMemo(
() => extractUserEmail(member.member),
[member.member]
);
- const group = useVueState(() => {
- if (!member.member.startsWith(groupBindingPrefix)) return undefined;
- return groupStore.getGroupByIdentifier(member.member);
- });
+ const group = useAppStore((state) =>
+ member.member.startsWith(groupBindingPrefix)
+ ? state.getGroupByIdentifier(member.member)
+ : undefined
+ );
const grantMatchesFilter = (grant: ExemptionGrant): boolean => {
if (!databaseFilter) return false;
diff --git a/frontend/src/react/pages/project/issue-detail/components/IssueDetailAccessGrantDetails.tsx b/frontend/src/react/pages/project/issue-detail/components/IssueDetailAccessGrantDetails.tsx
index a557f31083..bad6eb0c37 100644
--- a/frontend/src/react/pages/project/issue-detail/components/IssueDetailAccessGrantDetails.tsx
+++ b/frontend/src/react/pages/project/issue-detail/components/IssueDetailAccessGrantDetails.tsx
@@ -5,8 +5,8 @@ import { EngineIcon } from "@/react/components/EngineIcon";
import { Alert } from "@/react/components/ui/alert";
import { Checkbox } from "@/react/components/ui/checkbox";
import { useVueState } from "@/react/hooks/useVueState";
+import { useAppStore } from "@/react/stores/app";
import {
- useAccessGrantStore,
useDatabaseV1Store,
useEnvironmentV1Store,
useProjectV1Store,
@@ -24,7 +24,10 @@ export function IssueDetailAccessGrantDetails() {
const page = useIssueDetailContext();
const projectStore = useProjectV1Store();
const databaseStore = useDatabaseV1Store();
- const accessGrantStore = useAccessGrantStore();
+ const fetchAccessGrant = useAppStore((state) => state.fetchAccessGrant);
+ const searchMyAccessGrants = useAppStore(
+ (state) => state.searchMyAccessGrants
+ );
const projectName = `${projectNamePrefix}${page.projectId}`;
const project = useVueState(() => projectStore.getProjectByName(projectName));
const [isLoading, setIsLoading] = useState(true);
@@ -45,10 +48,10 @@ export function IssueDetailAccessGrantDetails() {
try {
let grant: AccessGrant | undefined;
if (hasProjectPermissionV2(project, "bb.accessGrants.get")) {
- grant = await accessGrantStore.getAccessGrant(name);
+ grant = await fetchAccessGrant(name);
} else {
const parent = `projects/${extractProjectResourceName(page.issue.name)}`;
- const response = await accessGrantStore.searchMyAccessGrants({
+ const response = await searchMyAccessGrants({
parent,
filter: { name },
});
@@ -78,7 +81,13 @@ export function IssueDetailAccessGrantDetails() {
return () => {
canceled = true;
};
- }, [accessGrantStore, databaseStore, page.issue, project]);
+ }, [
+ fetchAccessGrant,
+ searchMyAccessGrants,
+ databaseStore,
+ page.issue,
+ project,
+ ]);
const expirationInfo = accessGrant
? getAccessGrantExpirationText(accessGrant)
diff --git a/frontend/src/react/pages/project/issue-detail/components/IssueDetailApprovalFlow.tsx b/frontend/src/react/pages/project/issue-detail/components/IssueDetailApprovalFlow.tsx
index 9ef9735a36..f56f6d2d7a 100644
--- a/frontend/src/react/pages/project/issue-detail/components/IssueDetailApprovalFlow.tsx
+++ b/frontend/src/react/pages/project/issue-detail/components/IssueDetailApprovalFlow.tsx
@@ -7,7 +7,7 @@ import {
User,
X,
} from "lucide-react";
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
import { useTranslation } from "react-i18next";
import { issueServiceClientConnect } from "@/connect";
import { FeatureBadge } from "@/react/components/FeatureBadge";
@@ -16,10 +16,11 @@ import { Button } from "@/react/components/ui/button";
import { Tooltip } from "@/react/components/ui/tooltip";
import { useVueState } from "@/react/hooks/useVueState";
import { cn } from "@/react/lib/utils";
+import { useAppStore } from "@/react/stores/app";
+import { ensureGroupIdentifier } from "@/react/stores/app/group";
import {
pushNotification,
useCurrentUserV1,
- useGroupStore,
useProjectIamPolicyStore,
useProjectV1Store,
useUserStore,
@@ -501,10 +502,20 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {
const { t } = useTranslation();
const page = useIssueDetailContext();
const currentUser = useVueState(() => useCurrentUserV1().value);
- const groupStore = useGroupStore();
const projectStore = useProjectV1Store();
const projectIamPolicyStore = useProjectIamPolicyStore();
const userStore = useUserStore();
+ const batchGetOrFetchGroups = useAppStore(
+ (state) => state.batchGetOrFetchGroups
+ );
+ const groupsByName = useAppStore((state) => state.groupsByName);
+ // Resolve groups from the app store cache the prefetch above populates.
+ // Depending on `groupsByName` makes candidate computation recompute once
+ // the prefetched groups arrive.
+ const getGroupByIdentifier = useCallback(
+ (identifier: string) => groupsByName[ensureGroupIdentifier(identifier)],
+ [groupsByName]
+ );
const [potentialApprovers, setPotentialApprovers] = useState<UserMessage[]>(
[]
);
@@ -570,12 +581,16 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {
}, [groupNamesKey]);
useEffect(() => {
- void groupStore.batchGetOrFetchGroups(groupNames).catch(() => undefined);
- }, [groupNames, groupStore]);
+ void batchGetOrFetchGroups(groupNames).catch(() => undefined);
+ }, [groupNames, batchGetOrFetchGroups]);
const candidateEmailsKey = useVueState(() => {
const policy = projectIamPolicyStore.getProjectIamPolicy(projectName);
- const memberMap = memberMapToRolesInProjectIAM(policy, step);
+ const memberMap = memberMapToRolesInProjectIAM(
+ policy,
+ step,
+ getGroupByIdentifier
+ );
const candidates: string[] = [];
for (const fullname of memberMap.keys()) {
if (fullname.startsWith(userNamePrefix)) {
diff --git a/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.test.tsx b/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.test.tsx
index ac7ff5a1b1..324e707741 100644
--- a/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.test.tsx
+++ b/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.test.tsx
@@ -37,9 +37,6 @@ const mocks = vi.hoisted(() => ({
currentUserStore: {
value: { email: "[email protected]", name: "users/me" },
},
- groupStore: {
- batchGetOrFetchGroups: vi.fn(async () => []),
- },
projectIamPolicyStore: {
getOrFetchProjectIamPolicy: vi.fn(async () => ({})),
getProjectIamPolicy: vi.fn(() => ({ bindings: [] })),
@@ -92,7 +89,6 @@ vi.mock("@/connect", () => ({
vi.mock("@/store", () => ({
pushNotification: mocks.pushNotification,
useCurrentUserV1: () => mocks.currentUserStore,
- useGroupStore: () => mocks.groupStore,
useProjectIamPolicyStore: () => mocks.projectIamPolicyStore,
useProjectV1Store: () => mocks.projectStore,
useRoleStore: () => mocks.roleStore,
@@ -100,6 +96,13 @@ vi.mock("@/store", () => ({
useUserStore: () => mocks.userStore,
}));
+vi.mock("@/react/stores/app", () => ({
+ useAppStore: (selector: (state: unknown) => unknown) =>
+ selector({
+ batchGetOrFetchGroups: mocks.batchGetOrFetchGroups,
+ }),
+}));
+
vi.mock("@/store/modules/v1/common", () => ({
projectNamePrefix: "projects/",
roleNamePrefix: "roles/",
@@ -215,7 +218,7 @@ beforeEach(() => {
mocks.requestIssue.mockClear();
mocks.routerPush.mockClear();
mocks.pushNotification.mockClear();
- mocks.groupStore.batchGetOrFetchGroups.mockClear();
+ mocks.batchGetOrFetchGroups.mockClear();
mocks.projectIamPolicyStore.getOrFetchProjectIamPolicy.mockClear();
mocks.projectIamPolicyStore.getProjectIamPolicy.mockClear();
mocks.projectStore.getOrFetchProjectByName.mockClear();
diff --git a/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.tsx b/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.tsx
index bc2138462a..b73de4ec03 100644
--- a/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.tsx
+++ b/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.tsx
@@ -7,7 +7,7 @@ import {
User,
X,
} from "lucide-react";
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
import { useTranslation } from "react-i18next";
import { issueServiceClientConnect } from "@/connect";
import { FeatureBadge } from "@/react/components/FeatureBadge";
@@ -16,12 +16,13 @@ import { Button } from "@/react/components/ui/button";
import { Tooltip } from "@/react/components/ui/tooltip";
import { useVueState } from "@/react/hooks/useVueState";
import { cn } from "@/react/lib/utils";
+import { useAppStore } from "@/react/stores/app";
+import { ensureGroupIdentifier } from "@/react/stores/app/group";
import { router } from "@/router";
import { PROJECT_V1_ROUTE_ISSUE_DETAIL } from "@/router/dashboard/projectV1";
import {
pushNotification,
useCurrentUserV1,
- useGroupStore,
useProjectIamPolicyStore,
useProjectV1Store,
useUserStore,
@@ -663,10 +664,20 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {
const page = usePlanDetailContext();
const { patchState } = page;
const currentUser = useCurrentUserV1().value;
- const groupStore = useGroupStore();
const projectStore = useProjectV1Store();
const projectIamPolicyStore = useProjectIamPolicyStore();
const userStore = useUserStore();
+ const batchGetOrFetchGroups = useAppStore(
+ (state) => state.batchGetOrFetchGroups
+ );
+ const groupsByName = useAppStore((state) => state.groupsByName);
+ // Resolve groups from the app store cache the prefetch above populates.
+ // Depending on `groupsByName` makes candidate computation recompute once
+ // the prefetched groups arrive.
+ const getGroupByIdentifier = useCallback(
+ (identifier: string) => groupsByName[ensureGroupIdentifier(identifier)],
+ [groupsByName]
+ );
const [potentialApprovers, setPotentialApprovers] = useState<UserMessage[]>(
[]
);
@@ -734,12 +745,16 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {
);
useEffect(() => {
- void groupStore.batchGetOrFetchGroups(groupNames).catch(() => undefined);
- }, [groupNames, groupStore]);
+ void batchGetOrFetchGroups(groupNames).catch(() => undefined);
+ }, [groupNames, batchGetOrFetchGroups]);
const candidateEmailsKey = useMemo(() => {
if (!projectIamPolicy) return "";
- const memberMap = memberMapToRolesInProjectIAM(projectIamPolicy, step);
+ const memberMap = memberMapToRolesInProjectIAM(
+ projectIamPolicy,
+ step,
+ getGroupByIdentifier
+ );
const candidates: string[] = [];
for (const fullname of memberMap.keys()) {
if (fullname.startsWith(userNamePrefix)) {
@@ -747,7 +762,7 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {
}
}
return [...new Set(candidates)].sort().join("\u0000");
- }, [projectIamPolicy, step]);
+ }, [projectIamPolicy, step, getGroupByIdentifier]);
const candidateEmails = useMemo(
() => (candidateEmailsKey ? candidateEmailsKey.split("\u0000") : []),
[candidateEmailsKey]
diff --git a/frontend/src/react/pages/settings/GroupsPage.tsx b/frontend/src/react/pages/settings/GroupsPage.tsx
index bf8b041e71..f369f46ecd 100644
--- a/frontend/src/react/pages/settings/GroupsPage.tsx
+++ b/frontend/src/react/pages/settings/GroupsPage.tsx
@@ -47,13 +47,13 @@ import { Tooltip } from "@/react/components/ui/tooltip";
import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";
import { useVueState } from "@/react/hooks/useVueState";
import { cn } from "@/react/lib/utils";
+import { useAppStore } from "@/react/stores/app";
import { router } from "@/router";
import { SETTING_ROUTE_WORKSPACE_GENERAL } from "@/router/dashboard/workspaceSetting";
import {
pushNotification,
useActuatorV1Store,
useCurrentUserV1,
- useGroupStore,
useSettingV1Store,
useSubscriptionV1Store,
useUserStore,
@@ -118,8 +118,8 @@ function GroupTable({
}) {
const { t } = useTranslation();
const currentUser = useVueState(() => useCurrentUserV1().value);
- const groupStore = useGroupStore();
const userStore = useUserStore();
+ const deleteGroup = useAppStore((state) => state.deleteGroup);
const [expandedGroups, setExpandedGroups] = useState<Set<string>>(new Set());
const [memberCache, setMemberCache] = useState<Map<string, User[]>>(
@@ -217,7 +217,7 @@ function GroupTable({
if (!confirmed) return;
try {
- await groupStore.deleteGroup(group.name);
+ await deleteGroup(group.name);
onGroupDeleted(group);
pushNotification({
module: "bytebase",
@@ -228,7 +228,7 @@ function GroupTable({
// error shown by store
}
},
- [groupStore, onGroupDeleted, t]
+ [deleteGroup, onGroupDeleted, t]
);
if (groups.length === 0) {
@@ -482,12 +482,14 @@ function GroupForm({
onRemoved,
}: Omit<CreateGroupSheetProps, "open">) {
const { t } = useTranslation();
- const groupStore = useGroupStore();
const settingV1Store = useSettingV1Store();
const actuatorStore = useActuatorV1Store();
const currentUser = useVueState(() => useCurrentUserV1().value);
const isSaaSMode = useVueState(() => actuatorStore.isSaaSMode);
const userStore = useUserStore();
+ const createGroup = useAppStore((state) => state.createGroup);
+ const updateGroup = useAppStore((state) => state.updateGroup);
+ const deleteGroup = useAppStore((state) => state.deleteGroup);
const isEditMode = !!group;
const workspaceDomains = useVueState(
@@ -655,7 +657,7 @@ function GroupForm({
description,
members: dedupedMembers,
});
- const updated = await groupStore.updateGroup(validGroup);
+ const updated = await updateGroup(validGroup);
onUpdated(updated);
pushNotification({
module: "bytebase",
@@ -669,7 +671,7 @@ function GroupForm({
description,
members: dedupedMembers,
});
- const created = await groupStore.createGroup(validGroup);
+ const created = await createGroup(validGroup);
onUpdated(created);
pushNotification({
module: "bytebase",
@@ -689,7 +691,7 @@ function GroupForm({
if (!group) return;
setIsRequesting(true);
try {
- await groupStore.deleteGroup(group.name);
+ await deleteGroup(group.name);
onRemoved(group);
pushNotification({
module: "bytebase",
@@ -930,7 +932,8 @@ export function GroupsPage() {
const { t } = useTranslation();
const subscriptionStore = useSubscriptionV1Store();
const settingV1Store = useSettingV1Store();
- const groupStore = useGroupStore();
+ const listGroups = useAppStore((state) => state.listGroups);
+ const fetchGroup = useAppStore((state) => state.fetchGroup);
const hasUserGroupFeature = useVueState(() =>
subscriptionStore.hasInstanceFeature(PlanFeature.FEATURE_USER_GROUPS)
@@ -953,14 +956,14 @@ export function GroupsPage() {
// Groups paged data
const fetchGroups = useCallback(
async (params: { pageSize: number; pageToken: string }) => {
- const { groups, nextPageToken } = await groupStore.fetchGroupList({
+ const { groups, nextPageToken } = await listGroups({
pageSize: params.pageSize,
pageToken: params.pageToken,
filter: { query: groupSearchText },
});
return { list: groups, nextPageToken };
},
- [groupStore, groupSearchText]
+ [listGroups, groupSearchText]
);
const hasGroupListPermission = hasWorkspacePermissionV2("bb.groups.list");
@@ -981,8 +984,7 @@ export function GroupsPage() {
...router.currentRoute.value,
query: {},
});
- groupStore
- .getOrFetchGroupByIdentifier(name)
+ fetchGroup(name)
.then((group) => {
if (group) {
setEditingGroup(group);
diff --git a/frontend/src/react/pages/settings/IDPDetailPage.tsx b/frontend/src/react/pages/settings/IDPDetailPage.tsx
index 02964ca27b..369a3c9882 100644
--- a/frontend/src/react/pages/settings/IDPDetailPage.tsx
+++ b/frontend/src/react/pages/settings/IDPDetailPage.tsx
@@ -23,10 +23,10 @@ import {
} from "@/react/components/ui/dialog";
import { Input } from "@/react/components/ui/input";
import { useVueState } from "@/react/hooks/useVueState";
+import { useAppStore } from "@/react/stores/app";
import { router } from "@/router";
import { WORKSPACE_ROUTE_IDENTITY_PROVIDERS } from "@/router/dashboard/workspaceRoutes";
import { pushNotification } from "@/store";
-import { useIdentityProviderStore } from "@/store/modules/idp";
import {
getIdentityProviderResourceId,
idpNamePrefix,
@@ -1106,7 +1106,15 @@ function extractConfigState(idp: IdentityProvider) {
export function IDPDetailPage() {
const { t } = useTranslation();
- const identityProviderStore = useIdentityProviderStore();
+ const fetchIdentityProvider = useAppStore(
+ (state) => state.fetchIdentityProvider
+ );
+ const updateIdentityProvider = useAppStore(
+ (state) => state.updateIdentityProvider
+ );
+ const deleteIdentityProvider = useAppStore(
+ (state) => state.deleteIdentityProvider
+ );
// Reactively read idpId from Vue Router's current route params
const idpId = useVueState(
@@ -1179,8 +1187,7 @@ export function IDPDetailPage() {
setLocalIdp(null);
initializedRef.current = false;
- identityProviderStore
- .getOrFetchIdentityProviderByName(idpName)
+ fetchIdentityProvider(idpName)
.then((idp) => {
if (cancelled) return;
if (idp) {
@@ -1200,7 +1207,7 @@ export function IDPDetailPage() {
return () => {
cancelled = true;
};
- }, [idpName, identityProviderStore, initializeFromIdp]);
+ }, [idpName, fetchIdentityProvider, initializeFromIdp]);
const resourceId = useMemo(() => {
if (!localIdp) return "";
@@ -1328,8 +1335,7 @@ export function IDPDetailPage() {
setIsUpdating(true);
try {
- const updatedProvider =
- await identityProviderStore.patchIdentityProvider(updated);
+ const updatedProvider = await updateIdentityProvider(updated);
pushNotification({
module: "bytebase",
@@ -1369,7 +1375,7 @@ export function IDPDetailPage() {
if (!originalIdp) return;
try {
- await identityProviderStore.deleteIdentityProvider(originalIdp.name);
+ await deleteIdentityProvider(originalIdp.name);
pushNotification({
module: "bytebase",
diff --git a/frontend/src/react/pages/settings/IDPsPage.tsx b/frontend/src/react/pages/settings/IDPsPage.tsx
index 2e6af80121..378fe39d28 100644
--- a/frontend/src/react/pages/settings/IDPsPage.tsx
+++ b/frontend/src/react/pages/settings/IDPsPage.tsx
@@ -47,7 +47,9 @@ import {
TableHeader,
TableRow,
} from "@/react/components/ui/table";
+import { useIdentityProviderList } from "@/react/hooks/useAppState";
import { useVueState } from "@/react/hooks/useVueState";
+import { useAppStore } from "@/react/stores/app";
import { router } from "@/router";
import { WORKSPACE_ROUTE_IDENTITY_PROVIDER_DETAIL } from "@/router/dashboard/workspaceRoutes";
import {
@@ -55,7 +57,6 @@ import {
useActuatorV1Store,
useSubscriptionV1Store,
} from "@/store";
-import { useIdentityProviderStore } from "@/store/modules/idp";
import {
getIdentityProviderResourceId,
idpNamePrefix,
@@ -1299,7 +1300,10 @@ function CreateWizardDrawer({
onCreated: (provider: IdentityProvider) => void;
}) {
const { t } = useTranslation();
- const identityProviderStore = useIdentityProviderStore();
+ const createIdentityProvider = useAppStore(
+ (state) => state.createIdentityProvider
+ );
+ const identityProviderList = useIdentityProviderList();
const subscriptionStore = useSubscriptionV1Store();
useEscapeKey(onClose);
@@ -1553,8 +1557,7 @@ function CreateWizardDrawer({
if (!canCreate) return;
setIsCreating(true);
try {
- const createdProvider =
- await identityProviderStore.createIdentityProvider(idpToCreate);
+ const createdProvider = await createIdentityProvider(idpToCreate);
pushNotification({
module: "bytebase",
style: "SUCCESS",
@@ -1580,11 +1583,12 @@ function CreateWizardDrawer({
const validateResourceId = useCallback(
async (val: string) => {
- try {
- await identityProviderStore.getOrFetchIdentityProviderByName(
- `${idpNamePrefix}${val}`,
- true
- );
+ if (
+ val &&
+ identityProviderList.some(
+ (idp) => idp.name === `${idpNamePrefix}${val}`
+ )
+ ) {
return [
{
type: "error" as const,
@@ -1593,11 +1597,10 @@ function CreateWizardDrawer({
}),
},
];
- } catch {
- return [];
}
+ return [];
},
- [identityProviderStore, t]
+ [identityProviderList, t]
);
// Step labels
@@ -1968,7 +1971,10 @@ function CreateWizardDrawer({
export function IDPsPage() {
const { t } = useTranslation();
- const identityProviderStore = useIdentityProviderStore();
+ const identityProviderList = useIdentityProviderList();
+ const listIdentityProviders = useAppStore(
+ (state) => state.listIdentityProviders
+ );
const subscriptionStore = useSubscriptionV1Store();
@@ -1980,15 +1986,11 @@ export function IDPsPage() {
);
const canCreate = hasWorkspacePermissionV2("bb.identityProviders.create");
- const identityProviderList = useVueState(() => [
- ...identityProviderStore.identityProviderList,
- ]);
-
useEffect(() => {
- identityProviderStore
- .fetchIdentityProviderList(useActuatorV1Store().workspaceResourceName)
- .finally(() => setReady(true));
- }, []);
+ listIdentityProviders(useActuatorV1Store().workspaceResourceName).finally(
+ () => setReady(true)
+ );
+ }, [listIdentityProviders]);
const handleCreateSSO = () => {
if (!hasSSOFeature) return;
diff --git a/frontend/src/react/pages/settings/ServiceAccountsPage.tsx b/frontend/src/react/pages/settings/ServiceAccountsPage.tsx
index 8e2aac8b68..87bb9ca8fd 100644
--- a/frontend/src/react/pages/settings/ServiceAccountsPage.tsx
+++ b/frontend/src/react/pages/settings/ServiceAccountsPage.tsx
@@ -30,17 +30,17 @@ import { Tooltip } from "@/react/components/ui/tooltip";
import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";
import { useVueState } from "@/react/hooks/useVueState";
import { cn } from "@/react/lib/utils";
+import { useAppStore } from "@/react/stores/app";
import {
ensureServiceAccountFullName,
+ serviceAccountToUser,
+} from "@/react/stores/app/serviceAccount";
+import {
pushNotification,
useActuatorV1Store,
useProjectV1Store,
useWorkspaceV1Store,
} from "@/store";
-import {
- serviceAccountToUser,
- useServiceAccountStore,
-} from "@/store/modules/serviceAccount";
import { projectNamePrefix } from "@/store/modules/v1/common";
import { useProjectIamPolicyStore } from "@/store/modules/v1/projectIamPolicy";
import {
@@ -51,7 +51,7 @@ import { State } from "@/types/proto-es/v1/common_pb";
import { BindingSchema } from "@/types/proto-es/v1/iam_policy_pb";
import type { Project } from "@/types/proto-es/v1/project_service_pb";
import type { ServiceAccount } from "@/types/proto-es/v1/service_account_service_pb";
-import type { User } from "@/types/proto-es/v1/user_service_pb";
+import { type User, UserSchema } from "@/types/proto-es/v1/user_service_pb";
import { hasProjectPermissionV2, hasWorkspacePermissionV2 } from "@/utils";
function execCommandCopy(text: string): boolean {
@@ -98,7 +98,15 @@ function ServiceAccountTable({
onUserSelected?: (user: User) => void;
}) {
const { t } = useTranslation();
- const serviceAccountStore = useServiceAccountStore();
+ const deleteServiceAccount = useAppStore(
+ (state) => state.deleteServiceAccount
+ );
+ const undeleteServiceAccount = useAppStore(
+ (state) => state.undeleteServiceAccount
+ );
+ const updateServiceAccount = useAppStore(
+ (state) => state.updateServiceAccount
+ );
const handleDeactivate = async (user: User) => {
const confirmed = window.confirm(
@@ -107,13 +115,8 @@ function ServiceAccountTable({
if (!confirmed) return;
try {
- await serviceAccountStore.deleteServiceAccount(
- ensureServiceAccountFullName(user.email)
- );
- const updated = create(
- (await import("@/types/proto-es/v1/user_service_pb")).UserSchema,
- { ...user, state: State.DELETED }
- );
+ await deleteServiceAccount(ensureServiceAccountFullName(user.email));
+ const updated = create(UserSchema, { ...user, state: State.DELETED });
onUserUpdated(updated);
pushNotification({
module: "bytebase",
@@ -127,13 +130,8 @@ function ServiceAccountTable({
const handleRestore = async (user: User) => {
try {
- await serviceAccountStore.undeleteServiceAccount(
- ensureServiceAccountFullName(user.email)
- );
- const updated = create(
- (await import("@/types/proto-es/v1/user_service_pb")).UserSchema,
- { ...user, state: State.ACTIVE }
- );
+ await undeleteServiceAccount(ensureServiceAccountFullName(user.email));
+ const updated = create(UserSchema, { ...user, state: State.ACTIVE });
onUserUpdated(updated);
pushNotification({
module: "bytebase",
@@ -151,7 +149,7 @@ function ServiceAccountTable({
const handleResetKey = async (user: User) => {
setResetConfirmUser(undefined);
try {
- const sa = await serviceAccountStore.updateServiceAccount(
+ const sa = await updateServiceAccount(
{ name: ensureServiceAccountFullName(user.email) },
create(FieldMaskSchema, { paths: ["service_key"] })
);
@@ -428,7 +426,12 @@ function ServiceAccountForm({
onUpdated,
}: Omit<CreateServiceAccountSheetProps, "open">) {
const { t } = useTranslation();
- const serviceAccountStore = useServiceAccountStore();
+ const createServiceAccount = useAppStore(
+ (state) => state.createServiceAccount
+ );
+ const updateServiceAccount = useAppStore(
+ (state) => state.updateServiceAccount
+ );
const workspaceStore = useWorkspaceV1Store();
const actuatorStore = useActuatorV1Store();
const projectStore = useProjectV1Store();
@@ -525,7 +528,7 @@ function ServiceAccountForm({
};
const handleCreate = async () => {
- const sa = await serviceAccountStore.createServiceAccount(
+ const sa = await createServiceAccount(
emailPrefix.trim(),
{ title: title.trim() || emailPrefix.trim() },
parent
@@ -563,7 +566,7 @@ function ServiceAccountForm({
let updatedSa: ServiceAccount = serviceAccount;
if (updateMask.length > 0) {
- updatedSa = await serviceAccountStore.updateServiceAccount(
+ updatedSa = await updateServiceAccount(
{
name: ensureServiceAccountFullName(serviceAccount.email),
title,
@@ -672,8 +675,9 @@ function ServiceAccountForm({
export function ServiceAccountsPage({ projectId }: { projectId?: string }) {
const { t } = useTranslation();
const actuatorStore = useActuatorV1Store();
- const serviceAccountStore = useServiceAccountStore();
const projectStore = useProjectV1Store();
+ const listServiceAccounts = useAppStore((state) => state.listServiceAccounts);
+ const getServiceAccount = useAppStore((state) => state.getServiceAccount);
const projectName = projectId
? `${projectNamePrefix}${projectId}`
@@ -695,7 +699,7 @@ export function ServiceAccountsPage({ projectId }: { projectId?: string }) {
// Active service accounts
const fetchActive = useCallback(
async (params: { pageSize: number; pageToken: string }) => {
- const response = await serviceAccountStore.listServiceAccounts({
+ const response = await listServiceAccounts({
parent,
pageSize: params.pageSize,
pageToken: params.pageToken,
@@ -704,7 +708,7 @@ export function ServiceAccountsPage({ projectId }: { projectId?: string }) {
const list: User[] = response.serviceAccounts.map(serviceAccountToUser);
return { list, nextPageToken: response.nextPageToken };
},
- [serviceAccountStore, parent]
+ [listServiceAccounts, parent]
);
const activeData = usePagedData<User>({
@@ -715,7 +719,7 @@ export function ServiceAccountsPage({ projectId }: { projectId?: string }) {
// Inactive service accounts
const fetchInactive = useCallback(
async (params: { pageSize: number; pageToken: string }) => {
- const response = await serviceAccountStore.listServiceAccounts({
+ const response = await listServiceAccounts({
parent,
pageSize: params.pageSize,
pageToken: params.pageToken,
@@ -725,7 +729,7 @@ export function ServiceAccountsPage({ projectId }: { projectId?: string }) {
const list: User[] = response.serviceAccounts.map(serviceAccountToUser);
return { list, nextPageToken: response.nextPageToken };
},
- [serviceAccountStore, parent]
+ [listServiceAccounts, parent]
);
const inactiveData = usePagedData<User>({
@@ -753,7 +757,7 @@ export function ServiceAccountsPage({ projectId }: { projectId?: string }) {
};
const handleOpenEdit = (user: User) => {
- const sa = serviceAccountStore.getServiceAccount(user.email);
+ const sa = getServiceAccount(user.email);
setEditingSa(sa);
setShowDrawer(true);
};
diff --git a/frontend/src/react/pages/settings/UsersPage.tsx b/frontend/src/react/pages/settings/UsersPage.tsx
index e55d064c0b..55f7dc8975 100644
--- a/frontend/src/react/pages/settings/UsersPage.tsx
+++ b/frontend/src/react/pages/settings/UsersPage.tsx
@@ -42,6 +42,7 @@ import { Tooltip } from "@/react/components/ui/tooltip";
import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";
import { useVueState } from "@/react/hooks/useVueState";
import { cn } from "@/react/lib/utils";
+import { useAppStore } from "@/react/stores/app";
import { router } from "@/router";
import {
WORKSPACE_ROUTE_GROUPS,
@@ -51,12 +52,9 @@ import {
pushNotification,
useActuatorV1Store,
useCurrentUserV1,
- useGroupStore,
- useServiceAccountStore,
useSettingV1Store,
useSubscriptionV1Store,
useUserStore,
- useWorkloadIdentityStore,
useWorkspaceV1Store,
} from "@/store";
import { getUserFullNameByType } from "@/store/modules/v1/common";
@@ -94,18 +92,30 @@ function UserTable({
}) {
const { t } = useTranslation();
const currentUser = useVueState(() => useCurrentUserV1().value);
- const groupStore = useGroupStore();
const userStore = useUserStore();
- const serviceAccountStore = useServiceAccountStore();
- const workloadIdentityStore = useWorkloadIdentityStore();
+ const batchGetOrFetchGroups = useAppStore(
+ (state) => state.batchGetOrFetchGroups
+ );
+ const deleteServiceAccount = useAppStore(
+ (state) => state.deleteServiceAccount
+ );
+ const undeleteServiceAccount = useAppStore(
+ (state) => state.undeleteServiceAccount
+ );
+ const deleteWorkloadIdentity = useAppStore(
+ (state) => state.deleteWorkloadIdentity
+ );
+ const undeleteWorkloadIdentity = useAppStore(
+ (state) => state.undeleteWorkloadIdentity
+ );
// Batch fetch groups when user list changes
useEffect(() => {
const allGroupNames = users.flatMap((u) => u.groups);
if (allGroupNames.length > 0) {
- groupStore.batchGetOrFetchGroups(allGroupNames);
+ batchGetOrFetchGroups(allGroupNames);
}
- }, [users, groupStore]);
+ }, [users, batchGetOrFetchGroups]);
const handleDeactivate = async (user: User) => {
const accountType = getAccountTypeByEmail(user.email);
@@ -118,9 +128,9 @@ function UserTable({
try {
if (accountType === AccountType.SERVICE_ACCOUNT) {
- await serviceAccountStore.deleteServiceAccount(fullName);
+ await deleteServiceAccount(fullName);
} else if (accountType === AccountType.WORKLOAD_IDENTITY) {
- await workloadIdentityStore.deleteWorkloadIdentity(fullName);
+ await deleteWorkloadIdentity(fullName);
} else {
await userStore.archiveUser(fullName);
}
@@ -144,9 +154,9 @@ function UserTable({
try {
if (accountType === AccountType.SERVICE_ACCOUNT) {
- await serviceAccountStore.undeleteServiceAccount(fullName);
+ await undeleteServiceAccount(fullName);
} else if (accountType === AccountType.WORKLOAD_IDENTITY) {
- await workloadIdentityStore.undeleteWorkloadIdentity(fullName);
+ await undeleteWorkloadIdentity(fullName);
} else {
await userStore.restoreUser(fullName);
}
@@ -407,7 +417,9 @@ function UserGroupsCell({
user: User;
onGroupSelected?: (group: Group) => void;
}) {
- const groupStore = useGroupStore();
+ const getGroupByIdentifier = useAppStore(
+ (state) => state.getGroupByIdentifier
+ );
if (!user.groups || user.groups.length === 0) {
return <span className="text-control-light">-</span>;
@@ -416,7 +428,7 @@ function UserGroupsCell({
return (
<div className="flex flex-wrap gap-1">
{user.groups.map((groupName) => {
- const group = groupStore.getGroupByIdentifier(groupName);
+ const group = getGroupByIdentifier(groupName);
return (
<Badge
key={groupName}
diff --git a/frontend/src/react/pages/settings/WorkloadIdentitiesPage.tsx b/frontend/src/react/pages/settings/WorkloadIdentitiesPage.tsx
index d88a5ce98b..190fee6bb5 100644
--- a/frontend/src/react/pages/settings/WorkloadIdentitiesPage.tsx
+++ b/frontend/src/react/pages/settings/WorkloadIdentitiesPage.tsx
@@ -17,17 +17,17 @@ import {
import { Tooltip } from "@/react/components/ui/tooltip";
import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";
import { useVueState } from "@/react/hooks/useVueState";
+import { useAppStore } from "@/react/stores/app";
import {
ensureWorkloadIdentityFullName,
+ workloadIdentityToUser,
+} from "@/react/stores/app/workloadIdentity";
+import {
pushNotification,
useActuatorV1Store,
useProjectV1Store,
} from "@/store";
import { projectNamePrefix } from "@/store/modules/v1/common";
-import {
- useWorkloadIdentityStore,
- workloadIdentityToUser,
-} from "@/store/modules/workloadIdentity";
import { State } from "@/types/proto-es/v1/common_pb";
import type { Project } from "@/types/proto-es/v1/project_service_pb";
import type { User } from "@/types/proto-es/v1/user_service_pb";
@@ -50,7 +50,12 @@ function WorkloadIdentityTable({
onUserSelected?: (user: User) => void;
}) {
const { t } = useTranslation();
- const workloadIdentityStore = useWorkloadIdentityStore();
+ const deleteWorkloadIdentity = useAppStore(
+ (state) => state.deleteWorkloadIdentity
+ );
+ const undeleteWorkloadIdentity = useAppStore(
+ (state) => state.undeleteWorkloadIdentity
+ );
const handleDeactivate = async (user: User) => {
const confirmed = window.confirm(
@@ -60,7 +65,7 @@ function WorkloadIdentityTable({
try {
const fullName = ensureWorkloadIdentityFullName(user.email);
- await workloadIdentityStore.deleteWorkloadIdentity(fullName);
+ await deleteWorkloadIdentity(fullName);
const updated = { ...user, state: State.DELETED };
onUserUpdated(updated as User);
pushNotification({
@@ -76,7 +81,7 @@ function WorkloadIdentityTable({
const handleRestore = async (user: User) => {
try {
const fullName = ensureWorkloadIdentityFullName(user.email);
- await workloadIdentityStore.undeleteWorkloadIdentity(fullName);
+ await undeleteWorkloadIdentity(fullName);
const updated = { ...user, state: State.ACTIVE };
onUserUpdated(updated as User);
pushNotification({
@@ -232,9 +237,14 @@ function WorkloadIdentityTable({
export function WorkloadIdentitiesPage({ projectId }: { projectId?: string }) {
const { t } = useTranslation();
- const workloadIdentityStore = useWorkloadIdentityStore();
const actuatorStore = useActuatorV1Store();
const projectStore = useProjectV1Store();
+ const listWorkloadIdentities = useAppStore(
+ (state) => state.listWorkloadIdentities
+ );
+ const fetchWorkloadIdentity = useAppStore(
+ (state) => state.fetchWorkloadIdentity
+ );
const projectName = projectId
? `${projectNamePrefix}${projectId}`
@@ -255,7 +265,7 @@ export function WorkloadIdentitiesPage({ projectId }: { projectId?: string }) {
const fetchActive = useCallback(
async (params: { pageSize: number; pageToken: string }) => {
- const response = await workloadIdentityStore.listWorkloadIdentities({
+ const response = await listWorkloadIdentities({
parent,
pageSize: params.pageSize,
pageToken: params.pageToken,
@@ -266,12 +276,12 @@ export function WorkloadIdentitiesPage({ projectId }: { projectId?: string }) {
nextPageToken: response.nextPageToken,
};
},
- [workloadIdentityStore, parent]
+ [listWorkloadIdentities, parent]
);
const fetchInactive = useCallback(
async (params: { pageSize: number; pageToken: string }) => {
- const response = await workloadIdentityStore.listWorkloadIdentities({
+ const response = await listWorkloadIdentities({
parent,
pageSize: params.pageSize,
pageToken: params.pageToken,
@@ -283,7 +293,7 @@ export function WorkloadIdentitiesPage({ projectId }: { projectId?: string }) {
nextPageToken: response.nextPageToken,
};
},
- [workloadIdentityStore, parent]
+ [listWorkloadIdentities, parent]
);
const activeData = usePagedData<User>({
@@ -321,18 +331,14 @@ export function WorkloadIdentitiesPage({ projectId }: { projectId?: string }) {
// resolve out of order and open the sheet with the wrong identity.
const selectSeqRef = useRef(0);
const handleUserSelected = async (user: User) => {
- // Use getOrFetch so the full WorkloadIdentity (including
- // workloadIdentityConfig with subjectPattern) is loaded before we open
- // the edit Sheet. `getWorkloadIdentity` returns a stub with only
- // name/email/title if the cache is empty — which it is on first click
- // of a row, since listWorkloadIdentities doesn't populate the cache.
- // Without this, the edit Sheet would see no config and leave
- // Organization/Repository/Branch fields blank.
+ // Load the full WorkloadIdentity (including workloadIdentityConfig with
+ // subjectPattern) before opening the edit Sheet. The list response carries
+ // the full record, so this is usually a cache hit; fetchWorkloadIdentity
+ // only issues a GET when the entity isn't cached. `getWorkloadIdentity`
+ // would instead return a name/email/title-only stub on a cache miss,
+ // leaving Organization/Repository/Branch blank.
const seq = ++selectSeqRef.current;
- const wi = await workloadIdentityStore.getOrFetchWorkloadIdentity(
- user.email,
- true
- );
+ const wi = await fetchWorkloadIdentity(user.email, true);
// Drop stale response — a later click superseded this request.
if (seq !== selectSeqRef.current) return;
setEditingWI(wi);
diff --git a/frontend/src/react/pages/settings/general/AccountSection.tsx b/frontend/src/react/pages/settings/general/AccountSection.tsx
index bd3dd77acb..07c7a4ad58 100644
--- a/frontend/src/react/pages/settings/general/AccountSection.tsx
+++ b/frontend/src/react/pages/settings/general/AccountSection.tsx
@@ -22,7 +22,7 @@ import { Input } from "@/react/components/ui/input";
import { NumberInput } from "@/react/components/ui/number-input";
import { usePlanFeature, useServerState } from "@/react/hooks/useAppState";
import { useVueState } from "@/react/hooks/useVueState";
-import { useIdentityProviderStore } from "@/store";
+import { useAppStore } from "@/react/stores/app";
import { useSettingV1Store } from "@/store/modules/v1/setting";
import {
defaultAccessTokenDurationInHours,
@@ -97,7 +97,9 @@ export const AccountSection = forwardRef<SectionHandle, AccountSectionProps>(
const { t } = useTranslation();
const settingV1Store = useSettingV1Store();
- const idpStore = useIdentityProviderStore();
+ const listIdentityProviders = useAppStore(
+ (state) => state.listIdentityProviders
+ );
const { isSaaSMode, workspaceResourceName } = useServerState();
const hasDisallowSignupFeature = usePlanFeature(
@@ -116,8 +118,8 @@ export const AccountSection = forwardRef<SectionHandle, AccountSectionProps>(
const [allowEdit] = usePermissionCheck(["bb.settings.setWorkspaceProfile"]);
- const existActiveIdentityProvider = useVueState(
- () => idpStore.identityProviderList.length > 0
+ const existActiveIdentityProvider = useAppStore(
+ (state) => state.identityProviderList().length > 0
);
// Track whether the EMAIL setting is configured (required to enable email-code signin).
@@ -129,9 +131,9 @@ export const AccountSection = forwardRef<SectionHandle, AccountSectionProps>(
// Fetch identity providers after the workspace resource name is ready.
useEffect(() => {
if (workspaceResourceName) {
- idpStore.fetchIdentityProviderList(workspaceResourceName);
+ listIdentityProviders(workspaceResourceName);
}
- }, [idpStore, workspaceResourceName]);
+ }, [listIdentityProviders, workspaceResourceName]);
// Fetch EMAIL setting on mount.
useEffect(() => {
diff --git a/frontend/src/react/stores/app/accessGrant.ts b/frontend/src/react/stores/app/accessGrant.ts
new file mode 100644
index 0000000000..dce287f01a
--- /dev/null
+++ b/frontend/src/react/stores/app/accessGrant.ts
@@ -0,0 +1,186 @@
+import { create as createProto } from "@bufbuild/protobuf";
+import { accessGrantServiceClientConnect } from "@/connect";
+import type { AccessGrant } from "@/types/proto-es/v1/access_grant_service_pb";
+import {
+ AccessGrant_Status,
+ ActivateAccessGrantRequestSchema,
+ CreateAccessGrantRequestSchema,
+ GetAccessGrantRequestSchema,
+ ListAccessGrantsRequestSchema,
+ RevokeAccessGrantRequestSchema,
+ SearchMyAccessGrantsRequestSchema,
+} from "@/types/proto-es/v1/access_grant_service_pb";
+import type {
+ AccessGrantFilter,
+ AccessGrantSlice,
+ AppSliceCreator,
+} from "./types";
+
+export const buildAccessGrantFilter = (
+ filter: AccessGrantFilter | undefined,
+ now = new Date()
+): string => {
+ if (!filter) return "";
+ const parts: string[] = [];
+
+ if (filter.name) {
+ parts.push(`name == "${filter.name}"`);
+ }
+ if (filter.status !== undefined && filter.status.length > 0) {
+ const statusFilter: string[] = [];
+ for (const status of filter.status) {
+ switch (status) {
+ case "ACTIVE":
+ statusFilter.push(
+ `(status == "${AccessGrant_Status[AccessGrant_Status.ACTIVE]}" && expire_time > "${now.toISOString()}")`
+ );
+ break;
+ case "EXPIRED":
+ statusFilter.push(`expire_time <= "${now.toISOString()}"`);
+ break;
+ default:
+ statusFilter.push(
+ `status == "${status as keyof typeof AccessGrant_Status}"`
+ );
+ }
+ }
+ parts.push(`(${statusFilter.join(" || ")})`);
+ }
+ if (filter.statement) {
+ parts.push(`query.contains("${filter.statement.trim()}")`);
+ }
+ if (filter.creator) {
+ parts.push(`creator == "${filter.creator}"`);
+ }
+ if (filter.issue) {
+ parts.push(`issue == "${filter.issue}"`);
+ }
+ if (filter.target) {
+ parts.push(`target == "${filter.target}"`);
+ }
+ if (filter.createdTsAfter !== undefined) {
+ parts.push(
+ `create_time >= "${new Date(filter.createdTsAfter).toISOString()}"`
+ );
+ }
+ if (filter.createdTsBefore !== undefined) {
+ parts.push(
+ `create_time <= "${new Date(filter.createdTsBefore).toISOString()}"`
+ );
+ }
+ return parts.join(" && ");
+};
+
+const upsertAccessGrants = (
+ set: Parameters<AppSliceCreator<AccessGrantSlice>>[0],
+ accessGrants: AccessGrant[]
+) => {
+ set((state) => ({
+ accessGrantsByName: {
+ ...state.accessGrantsByName,
+ ...Object.fromEntries(accessGrants.map((grant) => [grant.name, grant])),
+ },
+ }));
+};
+
+export const createAccessGrantSlice: AppSliceCreator<AccessGrantSlice> = (
+ set,
+ get
+) => ({
+ accessGrantsByName: {},
+ accessGrantRequests: {},
+
+ fetchAccessGrant: async (name) => {
+ const existing = get().accessGrantsByName[name];
+ if (existing) return existing;
+ const pending = get().accessGrantRequests[name];
+ if (pending) return pending;
+
+ const request = accessGrantServiceClientConnect
+ .getAccessGrant(createProto(GetAccessGrantRequestSchema, { name }))
+ .then((grant) => {
+ set((state) => {
+ const { [name]: _, ...accessGrantRequests } =
+ state.accessGrantRequests;
+ return {
+ accessGrantsByName: {
+ ...state.accessGrantsByName,
+ [grant.name]: grant,
+ },
+ accessGrantRequests,
+ };
+ });
+ return grant;
+ })
+ .catch(() => {
+ set((state) => {
+ const { [name]: _, ...accessGrantRequests } =
+ state.accessGrantRequests;
+ return { accessGrantRequests };
+ });
+ return undefined;
+ });
+ set((state) => ({
+ accessGrantRequests: { ...state.accessGrantRequests, [name]: request },
+ }));
+ return request;
+ },
+
+ searchMyAccessGrants: async (params) => {
+ const response = await accessGrantServiceClientConnect.searchMyAccessGrants(
+ createProto(SearchMyAccessGrantsRequestSchema, {
+ parent: params.parent,
+ filter: buildAccessGrantFilter(params.filter),
+ pageSize: params.pageSize ?? 0,
+ pageToken: params.pageToken ?? "",
+ orderBy: params.orderBy ?? "",
+ })
+ );
+ upsertAccessGrants(set, response.accessGrants);
+ return {
+ accessGrants: response.accessGrants,
+ nextPageToken: response.nextPageToken,
+ };
+ },
+
+ listAccessGrants: async (params) => {
+ const response = await accessGrantServiceClientConnect.listAccessGrants(
+ createProto(ListAccessGrantsRequestSchema, {
+ parent: params.parent,
+ filter: buildAccessGrantFilter(params.filter),
+ pageSize: params.pageSize ?? 0,
+ pageToken: params.pageToken ?? "",
+ orderBy: params.orderBy ?? "",
+ })
+ );
+ upsertAccessGrants(set, response.accessGrants);
+ return {
+ accessGrants: response.accessGrants,
+ nextPageToken: response.nextPageToken,
+ };
+ },
+
+ createAccessGrant: async (parent, accessGrant) => {
+ const grant = await accessGrantServiceClientConnect.createAccessGrant(
+ createProto(CreateAccessGrantRequestSchema, { parent, accessGrant })
+ );
+ upsertAccessGrants(set, [grant]);
+ return grant;
+ },
+
+ activateAccessGrant: async (name) => {
+ const grant = await accessGrantServiceClientConnect.activateAccessGrant(
+ createProto(ActivateAccessGrantRequestSchema, { name })
+ );
+ upsertAccessGrants(set, [grant]);
+ return grant;
+ },
+
+ revokeAccessGrant: async (name) => {
+ const grant = await accessGrantServiceClientConnect.revokeAccessGrant(
+ createProto(RevokeAccessGrantRequestSchema, { name })
+ );
+ upsertAccessGrants(set, [grant]);
+ return grant;
+ },
+});
diff --git a/frontend/src/react/stores/app/database.ts b/frontend/src/react/stores/app/database.ts
index 2544032b03..730e7fcee8 100644
--- a/frontend/src/react/stores/app/database.ts
+++ b/frontend/src/react/stores/app/database.ts
@@ -8,11 +8,7 @@ import {
} from "@/types/proto-es/v1/database_service_pb";
import { isValidDatabaseName } from "@/types/v1/database";
import type { AppSliceCreator, DatabaseSlice } from "./types";
-
-function toError(error: unknown): Error {
- if (error instanceof Error) return error;
- return new Error(String(error));
-}
+import { toError } from "./utils";
export const createDatabaseSlice: AppSliceCreator<DatabaseSlice> = (
set,
diff --git a/frontend/src/react/stores/app/dbGroup.ts b/frontend/src/react/stores/app/dbGroup.ts
index a11dc3e7d4..f5cc539ac4 100644
--- a/frontend/src/react/stores/app/dbGroup.ts
+++ b/frontend/src/react/stores/app/dbGroup.ts
@@ -7,11 +7,7 @@ import {
ListDatabaseGroupsRequestSchema,
} from "@/types/proto-es/v1/database_group_service_pb";
import type { AppSliceCreator, DBGroupSlice } from "./types";
-
-function toError(error: unknown): Error {
- if (error instanceof Error) return error;
- return new Error(String(error));
-}
+import { toError } from "./utils";
export const createDBGroupSlice: AppSliceCreator<DBGroupSlice> = (
set,
diff --git a/frontend/src/react/stores/app/group.ts b/frontend/src/react/stores/app/group.ts
new file mode 100644
index 0000000000..7d6e363a02
--- /dev/null
+++ b/frontend/src/react/stores/app/group.ts
@@ -0,0 +1,181 @@
+import { create as createProto } from "@bufbuild/protobuf";
+import { createContextValues } from "@connectrpc/connect";
+import { uniq } from "lodash-es";
+import { groupServiceClientConnect } from "@/connect";
+import { silentContextKey } from "@/connect/context-key";
+import { isValidProjectName } from "@/react/lib/resourceName";
+import type { Group } from "@/types/proto-es/v1/group_service_pb";
+import {
+ BatchGetGroupsRequestSchema,
+ CreateGroupRequestSchema,
+ DeleteGroupRequestSchema,
+ GetGroupRequestSchema,
+ ListGroupsRequestSchema,
+ UpdateGroupRequestSchema,
+} from "@/types/proto-es/v1/group_service_pb";
+import type { AppSliceCreator, GroupFilter, GroupSlice } from "./types";
+import { toError } from "./utils";
+
+const groupNamePrefix = "groups/";
+
+export const extractGroupEmail = (emailResource: string) => {
+ const matches = emailResource.match(/^(?:group:|groups\/)(.+)$/);
+ return matches?.[1] ?? emailResource;
+};
+
+export const ensureGroupIdentifier = (id: string) => {
+ const email = extractGroupEmail(id);
+ return `${groupNamePrefix}${email}`;
+};
+
+export const buildGroupFilter = (params: GroupFilter) => {
+ const filter = [];
+ const search = params.query?.trim()?.toLowerCase();
+ if (search) {
+ filter.push(`(title.contains("${search}") || email.contains("${search}"))`);
+ }
+ if (isValidProjectName(params.project)) {
+ filter.push(`project == "${params.project}"`);
+ }
+ return filter.join(" && ");
+};
+
+export const createGroupSlice: AppSliceCreator<GroupSlice> = (set, get) => ({
+ groupsByName: {},
+ groupRequests: {},
+ groupErrorsByName: {},
+
+ listGroups: async ({ pageSize, pageToken, filter }) => {
+ if (!get().hasWorkspacePermission("bb.groups.list")) {
+ return { groups: [], nextPageToken: "" };
+ }
+ const response = await groupServiceClientConnect.listGroups(
+ createProto(ListGroupsRequestSchema, {
+ pageSize,
+ pageToken,
+ filter: buildGroupFilter(filter ?? {}),
+ }),
+ { contextValues: createContextValues().set(silentContextKey, true) }
+ );
+ set((state) => ({
+ groupsByName: {
+ ...state.groupsByName,
+ ...Object.fromEntries(
+ response.groups.map((group) => [group.name, group])
+ ),
+ },
+ }));
+ return { groups: response.groups, nextPageToken: response.nextPageToken };
+ },
+
+ batchFetchGroups: async (names) => {
+ const validNames = uniq(names).filter(Boolean).map(ensureGroupIdentifier);
+ if (validNames.length === 0) return [];
+ const response = await groupServiceClientConnect.batchGetGroups(
+ createProto(BatchGetGroupsRequestSchema, { names: validNames }),
+ { contextValues: createContextValues().set(silentContextKey, true) }
+ );
+ set((state) => ({
+ groupsByName: {
+ ...state.groupsByName,
+ ...Object.fromEntries(
+ response.groups.map((group) => [group.name, group])
+ ),
+ },
+ }));
+ return response.groups;
+ },
+
+ batchGetOrFetchGroups: async (names) => {
+ const validNames = uniq(names).filter(Boolean).map(ensureGroupIdentifier);
+ const missing = validNames.filter((name) => !get().groupsByName[name]);
+ if (missing.length > 0) {
+ await get().batchFetchGroups(missing);
+ }
+ return validNames.map((name) => get().groupsByName[name]);
+ },
+
+ fetchGroup: async (id) => {
+ if (!get().hasWorkspacePermission("bb.groups.get")) return undefined;
+ const name = ensureGroupIdentifier(id);
+ const existing = get().groupsByName[name];
+ if (existing) return existing;
+ const pending = get().groupRequests[name];
+ if (pending) return pending;
+
+ const request = groupServiceClientConnect
+ .getGroup(createProto(GetGroupRequestSchema, { name }), {
+ contextValues: createContextValues().set(silentContextKey, true),
+ })
+ .then((group: Group) => {
+ set((state) => {
+ const { [name]: _, ...groupRequests } = state.groupRequests;
+ return {
+ groupsByName: { ...state.groupsByName, [group.name]: group },
+ groupErrorsByName: {
+ ...state.groupErrorsByName,
+ [name]: undefined,
+ },
+ groupRequests,
+ };
+ });
+ return group;
+ })
+ .catch((error) => {
+ set((state) => {
+ const { [name]: _, ...groupRequests } = state.groupRequests;
+ return {
+ groupErrorsByName: {
+ ...state.groupErrorsByName,
+ [name]: toError(error),
+ },
+ groupRequests,
+ };
+ });
+ return undefined;
+ });
+ set((state) => ({
+ groupRequests: { ...state.groupRequests, [name]: request },
+ }));
+ return request;
+ },
+
+ getGroupByIdentifier: (id) => get().groupsByName[ensureGroupIdentifier(id)],
+
+ createGroup: async (group) => {
+ const response = await groupServiceClientConnect.createGroup(
+ createProto(CreateGroupRequestSchema, {
+ group,
+ groupEmail: extractGroupEmail(group.name),
+ })
+ );
+ set((state) => ({
+ groupsByName: { ...state.groupsByName, [response.name]: response },
+ }));
+ return response;
+ },
+
+ updateGroup: async (group) => {
+ const response = await groupServiceClientConnect.updateGroup(
+ createProto(UpdateGroupRequestSchema, {
+ group,
+ updateMask: { paths: ["title", "description", "members"] },
+ allowMissing: false,
+ })
+ );
+ set((state) => ({
+ groupsByName: { ...state.groupsByName, [response.name]: response },
+ }));
+ return response;
+ },
+
+ deleteGroup: async (name) => {
+ await groupServiceClientConnect.deleteGroup(
+ createProto(DeleteGroupRequestSchema, { name })
+ );
+ set((state) => {
+ const { [name]: _, ...groupsByName } = state.groupsByName;
+ return { groupsByName };
+ });
+ },
+});
diff --git a/frontend/src/react/stores/app/identityProvider.ts b/frontend/src/react/stores/app/identityProvider.ts
new file mode 100644
index 0000000000..6756875a86
--- /dev/null
+++ b/frontend/src/react/stores/app/identityProvider.ts
@@ -0,0 +1,157 @@
+import { clone, create as createProto } from "@bufbuild/protobuf";
+import { createContextValues } from "@connectrpc/connect";
+import { isEqual, isUndefined } from "lodash-es";
+import { identityProviderServiceClientConnect } from "@/connect";
+import { silentContextKey } from "@/connect/context-key";
+import type { IdentityProvider } from "@/types/proto-es/v1/idp_service_pb";
+import {
+ CreateIdentityProviderRequestSchema,
+ DeleteIdentityProviderRequestSchema,
+ GetIdentityProviderRequestSchema,
+ IdentityProviderSchema,
+ ListIdentityProvidersRequestSchema,
+ UpdateIdentityProviderRequestSchema,
+} from "@/types/proto-es/v1/idp_service_pb";
+import type { AppSliceCreator, IdentityProviderSlice } from "./types";
+
+const getUpdateMaskFromIdentityProvider = (
+ origin: IdentityProvider,
+ update: Partial<IdentityProvider>
+): string[] => {
+ const updateMask: string[] = [];
+ if (!isUndefined(update.title) && !isEqual(origin.title, update.title)) {
+ updateMask.push("title");
+ }
+ if (!isUndefined(update.domain) && !isEqual(origin.domain, update.domain)) {
+ updateMask.push("domain");
+ }
+ if (!isUndefined(update.config) && !isEqual(origin.config, update.config)) {
+ updateMask.push("config");
+ }
+ return updateMask;
+};
+
+export const createIdentityProviderSlice: AppSliceCreator<
+ IdentityProviderSlice
+> = (set, get) => ({
+ identityProvidersByName: {},
+ identityProviderRequests: {},
+
+ identityProviderList: () => Object.values(get().identityProvidersByName),
+
+ listIdentityProviders: async (parent) => {
+ const response =
+ await identityProviderServiceClientConnect.listIdentityProviders(
+ createProto(ListIdentityProvidersRequestSchema, {
+ parent: parent ?? "",
+ })
+ );
+ set({
+ identityProvidersByName: Object.fromEntries(
+ response.identityProviders.map((idp) => [idp.name, idp])
+ ),
+ });
+ return response.identityProviders;
+ },
+
+ fetchIdentityProvider: async (name, silent = false) => {
+ const existing = get().identityProvidersByName[name];
+ if (existing) return existing;
+ const pending = get().identityProviderRequests[name];
+ if (pending) return pending;
+
+ const request = identityProviderServiceClientConnect
+ .getIdentityProvider(
+ createProto(GetIdentityProviderRequestSchema, { name }),
+ { contextValues: createContextValues().set(silentContextKey, silent) }
+ )
+ .then((identityProvider) => {
+ set((state) => {
+ const { [name]: _, ...identityProviderRequests } =
+ state.identityProviderRequests;
+ return {
+ identityProvidersByName: {
+ ...state.identityProvidersByName,
+ [identityProvider.name]: identityProvider,
+ },
+ identityProviderRequests,
+ };
+ });
+ return identityProvider;
+ })
+ .catch(() => {
+ set((state) => {
+ const { [name]: _, ...identityProviderRequests } =
+ state.identityProviderRequests;
+ return { identityProviderRequests };
+ });
+ return undefined;
+ });
+ set((state) => ({
+ identityProviderRequests: {
+ ...state.identityProviderRequests,
+ [name]: request,
+ },
+ }));
+ return request;
+ },
+
+ getIdentityProvider: (name) => get().identityProvidersByName[name],
+
+ createIdentityProvider: async (identityProvider) => {
+ const idp =
+ await identityProviderServiceClientConnect.createIdentityProvider(
+ createProto(CreateIdentityProviderRequestSchema, {
+ identityProvider,
+ identityProviderId: identityProvider.name,
+ })
+ );
+ set((state) => ({
+ identityProvidersByName: {
+ ...state.identityProvidersByName,
+ [idp.name]: idp,
+ },
+ }));
+ return idp;
+ },
+
+ updateIdentityProvider: async (update) => {
+ const origin = await get().fetchIdentityProvider(update.name || "");
+ if (!origin) {
+ throw new Error(`identity provider with name ${update.name} not found`);
+ }
+ const fullProvider = clone(IdentityProviderSchema, origin);
+ if (update.title !== undefined) fullProvider.title = update.title;
+ if (update.domain !== undefined) fullProvider.domain = update.domain;
+ if (update.type !== undefined) fullProvider.type = update.type;
+ if (update.config !== undefined) fullProvider.config = update.config;
+
+ const idp =
+ await identityProviderServiceClientConnect.updateIdentityProvider(
+ createProto(UpdateIdentityProviderRequestSchema, {
+ identityProvider: fullProvider,
+ updateMask: {
+ paths: getUpdateMaskFromIdentityProvider(origin, update),
+ },
+ })
+ );
+ set((state) => ({
+ identityProvidersByName: {
+ ...state.identityProvidersByName,
+ [idp.name]: idp,
+ },
+ }));
+ return idp;
+ },
+
+ deleteIdentityProvider: async (name) => {
+ await identityProviderServiceClientConnect.deleteIdentityProvider(
+ createProto(DeleteIdentityProviderRequestSchema, { name })
+ );
+ set((state) => {
+ const { [name]: _, ...identityProvidersByName } =
+ state.identityProvidersByName;
+ return { identityProvidersByName };
+ });
+ },
+});
diff --git a/frontend/src/react/stores/app/index.test.ts b/frontend/src/react/stores/app/index.test.ts
index 323dbbe793..2d2766c510 100644
--- a/frontend/src/react/stores/app/index.test.ts
+++ b/frontend/src/react/stores/app/index.test.ts
@@ -2,18 +2,25 @@ import { create as createProto } from "@bufbuild/protobuf";
import { beforeEach, describe, expect, test, vi } from "vitest";
import { ReactShellBridgeEvent } from "@/react/shell-bridge";
import { ExprSchema } from "@/types/proto-es/google/type/expr_pb";
+import {
+ AccessGrant_Status,
+ AccessGrantSchema,
+} from "@/types/proto-es/v1/access_grant_service_pb";
import { ActuatorInfoSchema } from "@/types/proto-es/v1/actuator_service_pb";
import { State } from "@/types/proto-es/v1/common_pb";
import { DatabaseGroupSchema } from "@/types/proto-es/v1/database_group_service_pb";
import { DatabaseSchema$ } from "@/types/proto-es/v1/database_service_pb";
+import { GroupSchema } from "@/types/proto-es/v1/group_service_pb";
import {
BindingSchema,
IamPolicySchema,
} from "@/types/proto-es/v1/iam_policy_pb";
+import { IdentityProviderSchema } from "@/types/proto-es/v1/idp_service_pb";
import { InstanceRoleSchema } from "@/types/proto-es/v1/instance_role_service_pb";
import { InstanceSchema } from "@/types/proto-es/v1/instance_service_pb";
import { ProjectSchema } from "@/types/proto-es/v1/project_service_pb";
import { RoleSchema } from "@/types/proto-es/v1/role_service_pb";
+import { ServiceAccountSchema } from "@/types/proto-es/v1/service_account_service_pb";
import {
DatabaseChangeMode,
EnvironmentSetting_EnvironmentSchema,
@@ -29,6 +36,7 @@ import {
SubscriptionSchema,
} from "@/types/proto-es/v1/subscription_service_pb";
import { UserSchema } from "@/types/proto-es/v1/user_service_pb";
+import { WorkloadIdentitySchema } from "@/types/proto-es/v1/workload_identity_service_pb";
import {
storageKeyIntroState,
storageKeyRecentProjects,
@@ -73,6 +81,35 @@ const mocks = vi.hoisted(() => ({
getSheet: vi.fn(),
createSheet: vi.fn(),
listInstanceRoles: vi.fn(),
+ listGroups: vi.fn(),
+ batchGetGroups: vi.fn(),
+ getGroup: vi.fn(),
+ createGroup: vi.fn(),
+ updateGroup: vi.fn(),
+ deleteGroup: vi.fn(),
+ listServiceAccounts: vi.fn(),
+ getServiceAccount: vi.fn(),
+ createServiceAccount: vi.fn(),
+ updateServiceAccount: vi.fn(),
+ deleteServiceAccount: vi.fn(),
+ undeleteServiceAccount: vi.fn(),
+ listWorkloadIdentities: vi.fn(),
+ getWorkloadIdentity: vi.fn(),
+ createWorkloadIdentity: vi.fn(),
+ updateWorkloadIdentity: vi.fn(),
+ deleteWorkloadIdentity: vi.fn(),
+ undeleteWorkloadIdentity: vi.fn(),
+ listIdentityProviders: vi.fn(),
+ getIdentityProvider: vi.fn(),
+ createIdentityProvider: vi.fn(),
+ updateIdentityProvider: vi.fn(),
+ deleteIdentityProvider: vi.fn(),
+ getAccessGrant: vi.fn(),
+ searchMyAccessGrants: vi.fn(),
+ createAccessGrant: vi.fn(),
+ listAccessGrants: vi.fn(),
+ activateAccessGrant: vi.fn(),
+ revokeAccessGrant: vi.fn(),
}));
vi.mock("@/connect", () => ({
@@ -108,6 +145,45 @@ vi.mock("@/connect", () => ({
instanceRoleServiceClientConnect: {
listInstanceRoles: mocks.listInstanceRoles,
},
+ groupServiceClientConnect: {
+ listGroups: mocks.listGroups,
+ batchGetGroups: mocks.batchGetGroups,
+ getGroup: mocks.getGroup,
+ createGroup: mocks.createGroup,
+ updateGroup: mocks.updateGroup,
+ deleteGroup: mocks.deleteGroup,
+ },
+ serviceAccountServiceClientConnect: {
+ listServiceAccounts: mocks.listServiceAccounts,
+ getServiceAccount: mocks.getServiceAccount,
+ createServiceAccount: mocks.createServiceAccount,
+ updateServiceAccount: mocks.updateServiceAccount,
+ deleteServiceAccount: mocks.deleteServiceAccount,
+ undeleteServiceAccount: mocks.undeleteServiceAccount,
+ },
+ workloadIdentityServiceClientConnect: {
+ listWorkloadIdentities: mocks.listWorkloadIdentities,
+ getWorkloadIdentity: mocks.getWorkloadIdentity,
+ createWorkloadIdentity: mocks.createWorkloadIdentity,
+ updateWorkloadIdentity: mocks.updateWorkloadIdentity,
+ deleteWorkloadIdentity: mocks.deleteWorkloadIdentity,
+ undeleteWorkloadIdentity: mocks.undeleteWorkloadIdentity,
+ },
+ identityProviderServiceClientConnect: {
+ listIdentityProviders: mocks.listIdentityProviders,
+ getIdentityProvider: mocks.getIdentityProvider,
+ createIdentityProvider: mocks.createIdentityProvider,
+ updateIdentityProvider: mocks.updateIdentityProvider,
+ deleteIdentityProvider: mocks.deleteIdentityProvider,
+ },
+ accessGrantServiceClientConnect: {
+ getAccessGrant: mocks.getAccessGrant,
+ searchMyAccessGrants: mocks.searchMyAccessGrants,
+ createAccessGrant: mocks.createAccessGrant,
+ listAccessGrants: mocks.listAccessGrants,
+ activateAccessGrant: mocks.activateAccessGrant,
+ revokeAccessGrant: mocks.revokeAccessGrant,
+ },
roleServiceClientConnect: {
listRoles: mocks.listRoles,
},
@@ -146,6 +222,43 @@ const projectB = createProto(ProjectSchema, {
state: State.ACTIVE,
});
+const groupA = createProto(GroupSchema, {
+ name: "groups/[email protected]",
+ email: "[email protected]",
+ title: "DBA",
+});
+
+const groupB = createProto(GroupSchema, {
+ name: "groups/[email protected]",
+ email: "[email protected]",
+ title: "Dev",
+});
+
+const serviceAccountA = createProto(ServiceAccountSchema, {
+ name: "serviceAccounts/[email protected]",
+ email: "[email protected]",
+ title: "Robot",
+ state: State.ACTIVE,
+});
+
+const workloadIdentityA = createProto(WorkloadIdentitySchema, {
+ name: "workloadIdentities/[email protected]",
+ email: "[email protected]",
+ title: "Deploy",
+ state: State.ACTIVE,
+});
+
+const identityProviderA = createProto(IdentityProviderSchema, {
+ name: "idps/google",
+ title: "Google",
+ domain: "example.com",
+});
+
+const accessGrantA = createProto(AccessGrantSchema, {
+ name: "projects/a/accessGrants/ag1",
+ status: AccessGrant_Status.ACTIVE,
+});
+
const timestampSeconds = (seconds: number) => ({
seconds: BigInt(seconds),
nanos: 0,
@@ -171,6 +284,187 @@ describe("useAppStore", () => {
expect(state.removeRecentVisit).toBeTypeOf("function");
});
+ test("lists groups and populates the group cache", async () => {
+ mocks.listGroups.mockResolvedValue({
+ groups: [groupA, groupB],
+ nextPageToken: "next",
+ });
+ const store = createAppStore();
+ store.setState({
+ currentUser: user,
+ roles: [
+ createProto(RoleSchema, {
+ name: "roles/group-viewer",
+ permissions: ["bb.groups.list"],
+ }),
+ ],
+ workspacePolicy: createProto(IamPolicySchema, {
+ bindings: [
+ createProto(BindingSchema, {
+ role: "roles/group-viewer",
+ members: [`user:${user.email}`],
+ }),
+ ],
+ }),
+ });
+
+ const result = await store.getState().listGroups({ pageSize: 50 });
+
+ expect(result.groups).toEqual([groupA, groupB]);
+ expect(result.nextPageToken).toBe("next");
+ expect(store.getState().groupsByName[groupA.name]).toBe(groupA);
+ expect(store.getState().groupsByName[groupB.name]).toBe(groupB);
+ });
+
+ test("batchGetOrFetchGroups skips cached groups and preserves order", async () => {
+ mocks.batchGetGroups.mockResolvedValue({ groups: [groupB] });
+ const store = createAppStore();
+ store.setState({ groupsByName: { [groupA.name]: groupA } });
+
+ const result = await store
+ .getState()
+ .batchGetOrFetchGroups([groupA.name, groupB.name, groupA.name]);
+
+ expect(mocks.batchGetGroups).toHaveBeenCalledTimes(1);
+ expect(result).toEqual([groupA, groupB]);
+ expect(store.getState().groupsByName[groupB.name]).toBe(groupB);
+ });
+
+ test("lists service accounts and writes them into cache", async () => {
+ mocks.listServiceAccounts.mockResolvedValue({
+ serviceAccounts: [serviceAccountA],
+ nextPageToken: "next-sa",
+ });
+ const store = createAppStore();
+
+ const result = await store.getState().listServiceAccounts({
+ parent: "workspaces/default",
+ pageSize: 20,
+ showDeleted: false,
+ });
+
+ expect(result.serviceAccounts).toEqual([serviceAccountA]);
+ expect(result.nextPageToken).toBe("next-sa");
+ expect(store.getState().serviceAccountsByName[serviceAccountA.name]).toBe(
+ serviceAccountA
+ );
+ });
+
+ test("marks cached service account deleted after delete", async () => {
+ mocks.deleteServiceAccount.mockResolvedValue({});
+ const store = createAppStore();
+ store.setState({
+ serviceAccountsByName: { [serviceAccountA.name]: serviceAccountA },
+ });
+
+ await store.getState().deleteServiceAccount(serviceAccountA.name);
+
+ expect(
+ store.getState().serviceAccountsByName[serviceAccountA.name].state
+ ).toBe(State.DELETED);
+ });
+
+ test("lists workload identities and writes them into cache", async () => {
+ mocks.listWorkloadIdentities.mockResolvedValue({
+ workloadIdentities: [workloadIdentityA],
+ nextPageToken: "next-wi",
+ });
+ const store = createAppStore();
+
+ const result = await store.getState().listWorkloadIdentities({
+ parent: "workspaces/default",
+ pageSize: 20,
+ showDeleted: false,
+ });
+
+ expect(result.workloadIdentities).toEqual([workloadIdentityA]);
+ expect(result.nextPageToken).toBe("next-wi");
+ expect(
+ store.getState().workloadIdentitiesByName[workloadIdentityA.name]
+ ).toBe(workloadIdentityA);
+ });
+
+ test("lists identity providers and replaces the identity provider cache", async () => {
+ mocks.listIdentityProviders.mockResolvedValue({
+ identityProviders: [identityProviderA],
+ });
+ const store = createAppStore();
+ store.setState({
+ identityProvidersByName: {
+ "idps/stale": createProto(IdentityProviderSchema, {
+ name: "idps/stale",
+ }),
+ },
+ });
+
+ const providers = await store.getState().listIdentityProviders();
+
+ expect(providers).toEqual([identityProviderA]);
+ expect(store.getState().identityProviderList()).toEqual([
+ identityProviderA,
+ ]);
+ expect(store.getState().identityProvidersByName).toEqual({
+ [identityProviderA.name]: identityProviderA,
+ });
+ });
+
+ test("updates identity provider with a field mask based on changed fields", async () => {
+ mocks.getIdentityProvider.mockResolvedValue(identityProviderA);
+ mocks.updateIdentityProvider.mockResolvedValue({
+ ...identityProviderA,
+ title: "Google Workspace",
+ });
+ const store = createAppStore();
+
+ const updated = await store.getState().updateIdentityProvider({
+ name: identityProviderA.name,
+ title: "Google Workspace",
+ });
+
+ expect(updated.title).toBe("Google Workspace");
+ expect(mocks.updateIdentityProvider).toHaveBeenCalledWith(
+ expect.objectContaining({
+ updateMask: expect.objectContaining({ paths: ["title"] }),
+ })
+ );
+ });
+
+ test("lists access grants and writes them into cache", async () => {
+ mocks.listAccessGrants.mockResolvedValue({
+ accessGrants: [accessGrantA],
+ nextPageToken: "next-ag",
+ });
+ const store = createAppStore();
+
+ const result = await store.getState().listAccessGrants({
+ parent: "projects/a",
+ pageSize: 20,
+ filter: { status: ["ACTIVE"] },
+ });
+
+ expect(result.accessGrants).toEqual([accessGrantA]);
+ expect(result.nextPageToken).toBe("next-ag");
+ expect(store.getState().accessGrantsByName[accessGrantA.name]).toBe(
+ accessGrantA
+ );
+ });
+
+ test("revokeAccessGrant writes returned grant into cache", async () => {
+ const revoked = {
+ ...accessGrantA,
+ status: AccessGrant_Status.REVOKED,
+ };
+ mocks.revokeAccessGrant.mockResolvedValue(revoked);
+ const store = createAppStore();
+
+ const result = await store.getState().revokeAccessGrant(accessGrantA.name);
+
+ expect(result).toBe(revoked);
+ expect(store.getState().accessGrantsByName[accessGrantA.name]).toBe(
+ revoked
+ );
+ });
+
test("deduplicates project fetches and caches the result", async () => {
mocks.getProject.mockResolvedValue(projectA);
const store = createAppStore();
diff --git a/frontend/src/react/stores/app/index.ts b/frontend/src/react/stores/app/index.ts
index b17367c0ea..aa06a939c9 100644
--- a/frontend/src/react/stores/app/index.ts
+++ b/frontend/src/react/stores/app/index.ts
@@ -1,15 +1,20 @@
import { create } from "zustand";
+import { createAccessGrantSlice } from "./accessGrant";
import { createAuthSlice } from "./auth";
import { createDatabaseSlice } from "./database";
import { createDBGroupSlice } from "./dbGroup";
+import { createGroupSlice } from "./group";
import { createIamSlice } from "./iam";
+import { createIdentityProviderSlice } from "./identityProvider";
import { createInstanceSlice } from "./instance";
import { createInstanceRoleSlice } from "./instanceRole";
import { createNotificationSlice } from "./notification";
import { createPreferencesSlice } from "./preferences";
import { createProjectSlice } from "./project";
+import { createServiceAccountSlice } from "./serviceAccount";
import { createSheetSlice } from "./sheet";
import { createWorkspaceSlice } from "./workspace";
+import { createWorkloadIdentitySlice } from "./workloadIdentity";
export type { AppStoreState } from "./types";
export {
@@ -31,6 +36,11 @@ export const createAppStore = () =>
...createDBGroupSlice(...args),
...createSheetSlice(...args),
...createInstanceRoleSlice(...args),
+ ...createGroupSlice(...args),
+ ...createServiceAccountSlice(...args),
+ ...createWorkloadIdentitySlice(...args),
+ ...createIdentityProviderSlice(...args),
+ ...createAccessGrantSlice(...args),
...createNotificationSlice(...args),
...createPreferencesSlice(...args),
}));
diff --git a/frontend/src/react/stores/app/instance.ts b/frontend/src/react/stores/app/instance.ts
index e36050a89c..84b9f5e73c 100644
--- a/frontend/src/react/stores/app/instance.ts
+++ b/frontend/src/react/stores/app/instance.ts
@@ -9,11 +9,7 @@ import {
UNKNOWN_INSTANCE_NAME,
} from "@/types/v1/instance";
import type { AppSliceCreator, InstanceSlice } from "./types";
-
-function toError(error: unknown): Error {
- if (error instanceof Error) return error;
- return new Error(String(error));
-}
+import { toError } from "./utils";
export const createInstanceSlice: AppSliceCreator<InstanceSlice> = (
set,
diff --git a/frontend/src/react/stores/app/project.ts b/frontend/src/react/stores/app/project.ts
index 813bf1e8bb..15653bcbd2 100644
--- a/frontend/src/react/stores/app/project.ts
+++ b/frontend/src/react/stores/app/project.ts
@@ -11,7 +11,7 @@ import {
SearchProjectsRequestSchema,
} from "@/types/proto-es/v1/project_service_pb";
import type { AppSliceCreator, ProjectSlice } from "./types";
-import { buildProjectFilter, defaultProjectName } from "./utils";
+import { buildProjectFilter, defaultProjectName, toError } from "./utils";
const UNKNOWN_PROJECT_NAME = `projects/${UNKNOWN_ID}`;
@@ -28,11 +28,6 @@ function createDefaultProject(name: string) {
});
}
-function toError(error: unknown): Error {
- if (error instanceof Error) return error;
- return new Error(String(error));
-}
-
export const createProjectSlice: AppSliceCreator<ProjectSlice> = (
set,
get
diff --git a/frontend/src/react/stores/app/serviceAccount.ts b/frontend/src/react/stores/app/serviceAccount.ts
new file mode 100644
index 0000000000..098e1d5922
--- /dev/null
+++ b/frontend/src/react/stores/app/serviceAccount.ts
@@ -0,0 +1,207 @@
+import { create as createProto } from "@bufbuild/protobuf";
+import { createContextValues } from "@connectrpc/connect";
+import { serviceAccountServiceClientConnect } from "@/connect";
+import { silentContextKey } from "@/connect/context-key";
+import { State } from "@/types/proto-es/v1/common_pb";
+import type { ServiceAccount } from "@/types/proto-es/v1/service_account_service_pb";
+import {
+ CreateServiceAccountRequestSchema,
+ DeleteServiceAccountRequestSchema,
+ GetServiceAccountRequestSchema,
+ ListServiceAccountsRequestSchema,
+ ServiceAccountSchema,
+ UndeleteServiceAccountRequestSchema,
+ UpdateServiceAccountRequestSchema,
+} from "@/types/proto-es/v1/service_account_service_pb";
+import { type User, UserSchema } from "@/types/proto-es/v1/user_service_pb";
+import type {
+ AccountFilter,
+ AppSliceCreator,
+ ServiceAccountSlice,
+} from "./types";
+
+const serviceAccountNamePrefix = "serviceAccounts/";
+
+export const extractServiceAccountId = (identifier: string) => {
+ const matches = identifier.match(
+ /^(?:serviceAccount:|serviceAccounts\/)(.+)$/
+ );
+ return matches?.[1] ?? identifier;
+};
+
+export const ensureServiceAccountFullName = (identifier: string) => {
+ const id = extractServiceAccountId(identifier);
+ return `${serviceAccountNamePrefix}${id}`;
+};
+
+export const buildAccountListFilter = (params: AccountFilter) => {
+ const filter = [];
+ const search = params.query?.trim()?.toLowerCase();
+ if (search) {
+ filter.push(`(name.contains("${search}") || email.contains("${search}"))`);
+ }
+ if (params.state === State.DELETED) {
+ filter.push(`state == "${State[params.state]}"`);
+ }
+ return filter.join(" && ");
+};
+
+export const serviceAccountToUser = (sa: ServiceAccount): User => {
+ return createProto(UserSchema, {
+ name: `users/${sa.email}`,
+ email: sa.email,
+ title: sa.title,
+ state: sa.state,
+ serviceKey: sa.serviceKey,
+ });
+};
+
+export const createServiceAccountSlice: AppSliceCreator<ServiceAccountSlice> = (
+ set,
+ get
+) => ({
+ serviceAccountsByName: {},
+ serviceAccountRequests: {},
+
+ listServiceAccounts: async (params) => {
+ const response =
+ await serviceAccountServiceClientConnect.listServiceAccounts(
+ createProto(ListServiceAccountsRequestSchema, {
+ parent: params.parent,
+ pageSize: params.pageSize,
+ pageToken: params.pageToken,
+ showDeleted: params.showDeleted,
+ filter: buildAccountListFilter(params.filter ?? {}),
+ })
+ );
+ set((state) => ({
+ serviceAccountsByName: {
+ ...state.serviceAccountsByName,
+ ...Object.fromEntries(
+ response.serviceAccounts.map((sa) => [sa.name, sa])
+ ),
+ },
+ }));
+ return {
+ serviceAccounts: response.serviceAccounts,
+ nextPageToken: response.nextPageToken,
+ };
+ },
+
+ fetchServiceAccount: async (name, silent = false) => {
+ const validName = ensureServiceAccountFullName(name);
+ const existing = get().serviceAccountsByName[validName];
+ if (existing) return existing;
+ const pending = get().serviceAccountRequests[validName];
+ if (pending) return pending;
+
+ const request = serviceAccountServiceClientConnect
+ .getServiceAccount(
+ createProto(GetServiceAccountRequestSchema, { name: validName }),
+ { contextValues: createContextValues().set(silentContextKey, silent) }
+ )
+ .then((serviceAccount) => {
+ set((state) => {
+ const { [validName]: _, ...serviceAccountRequests } =
+ state.serviceAccountRequests;
+ return {
+ serviceAccountsByName: {
+ ...state.serviceAccountsByName,
+ [serviceAccount.name]: serviceAccount,
+ },
+ serviceAccountRequests,
+ };
+ });
+ return serviceAccount;
+ })
+ .catch(() => {
+ set((state) => {
+ const { [validName]: _, ...serviceAccountRequests } =
+ state.serviceAccountRequests;
+ return { serviceAccountRequests };
+ });
+ return undefined;
+ });
+ set((state) => ({
+ serviceAccountRequests: {
+ ...state.serviceAccountRequests,
+ [validName]: request,
+ },
+ }));
+ return request;
+ },
+
+ getServiceAccount: (name) => {
+ const validName = ensureServiceAccountFullName(name);
+ const email = extractServiceAccountId(validName);
+ return (
+ get().serviceAccountsByName[validName] ??
+ createProto(ServiceAccountSchema, {
+ name: validName,
+ email,
+ state: State.ACTIVE,
+ title: email.split("@")[0],
+ })
+ );
+ },
+
+ createServiceAccount: async (serviceAccountId, serviceAccount, parent) => {
+ const sa = await serviceAccountServiceClientConnect.createServiceAccount(
+ createProto(CreateServiceAccountRequestSchema, {
+ parent,
+ serviceAccountId,
+ serviceAccount: createProto(
+ ServiceAccountSchema,
+ serviceAccount as ServiceAccount
+ ),
+ })
+ );
+ set((state) => ({
+ serviceAccountsByName: { ...state.serviceAccountsByName, [sa.name]: sa },
+ }));
+ return sa;
+ },
+
+ updateServiceAccount: async (serviceAccount, updateMask) => {
+ const sa = await serviceAccountServiceClientConnect.updateServiceAccount(
+ createProto(UpdateServiceAccountRequestSchema, {
+ serviceAccount: createProto(
+ ServiceAccountSchema,
+ serviceAccount as ServiceAccount
+ ),
+ updateMask,
+ })
+ );
+ set((state) => ({
+ serviceAccountsByName: { ...state.serviceAccountsByName, [sa.name]: sa },
+ }));
+ return sa;
+ },
+
+ deleteServiceAccount: async (name) => {
+ const validName = ensureServiceAccountFullName(name);
+ await serviceAccountServiceClientConnect.deleteServiceAccount(
+ createProto(DeleteServiceAccountRequestSchema, { name: validName })
+ );
+ set((state) => {
+ const cached = state.serviceAccountsByName[validName];
+ if (!cached) return {};
+ return {
+ serviceAccountsByName: {
+ ...state.serviceAccountsByName,
+ [validName]: { ...cached, state: State.DELETED },
+ },
+ };
+ });
+ },
+
+ undeleteServiceAccount: async (name) => {
+ const sa = await serviceAccountServiceClientConnect.undeleteServiceAccount(
+ createProto(UndeleteServiceAccountRequestSchema, { name })
+ );
+ set((state) => ({
+ serviceAccountsByName: { ...state.serviceAccountsByName, [sa.name]: sa },
+ }));
+ return sa;
+ },
+});
diff --git a/frontend/src/react/stores/app/sheet.ts b/frontend/src/react/stores/app/sheet.ts
index f55255dbf7..395e7d2302 100644
--- a/frontend/src/react/stores/app/sheet.ts
+++ b/frontend/src/react/stores/app/sheet.ts
@@ -7,11 +7,7 @@ import {
} from "@/types/proto-es/v1/sheet_service_pb";
import { extractSheetUID } from "@/utils/v1/sheet";
import type { AppSliceCreator, SheetSlice } from "./types";
-
-function toError(error: unknown): Error {
- if (error instanceof Error) return error;
- return new Error(String(error));
-}
+import { toError } from "./utils";
function isValidSheetName(name: string): boolean {
if (typeof name !== "string") return false;
diff --git a/frontend/src/react/stores/app/types.ts b/frontend/src/react/stores/app/types.ts
index a6e08b1de0..7554b84272 100644
--- a/frontend/src/react/stores/app/types.ts
+++ b/frontend/src/react/stores/app/types.ts
@@ -2,10 +2,14 @@ import type { StateCreator } from "zustand";
import type { AppFeatures } from "@/types/appProfile";
import type { Permission } from "@/types/iam/permission";
import type { NotificationCreate } from "@/types/notification";
+import type { AccessGrant } from "@/types/proto-es/v1/access_grant_service_pb";
import type { ActuatorInfo } from "@/types/proto-es/v1/actuator_service_pb";
+import type { State } from "@/types/proto-es/v1/common_pb";
import type { DatabaseGroup } from "@/types/proto-es/v1/database_group_service_pb";
import type { Database } from "@/types/proto-es/v1/database_service_pb";
+import type { Group } from "@/types/proto-es/v1/group_service_pb";
import type { IamPolicy } from "@/types/proto-es/v1/iam_policy_pb";
+import type { IdentityProvider } from "@/types/proto-es/v1/idp_service_pb";
import type { InstanceRole } from "@/types/proto-es/v1/instance_role_service_pb";
import type {
Instance,
@@ -13,6 +17,7 @@ import type {
} from "@/types/proto-es/v1/instance_service_pb";
import type { Project } from "@/types/proto-es/v1/project_service_pb";
import type { Role } from "@/types/proto-es/v1/role_service_pb";
+import type { ServiceAccount } from "@/types/proto-es/v1/service_account_service_pb";
import type { WorkspaceProfileSetting } from "@/types/proto-es/v1/setting_service_pb";
import type { Sheet } from "@/types/proto-es/v1/sheet_service_pb";
import type {
@@ -21,8 +26,10 @@ import type {
Subscription,
} from "@/types/proto-es/v1/subscription_service_pb";
import type { User } from "@/types/proto-es/v1/user_service_pb";
+import type { WorkloadIdentity } from "@/types/proto-es/v1/workload_identity_service_pb";
import type { Workspace } from "@/types/proto-es/v1/workspace_service_pb";
import type { Environment } from "@/types/v1/environment";
+import type { AccessGrantFilterStatus } from "@/utils";
export type ProjectListParams = {
pageSize: number;
@@ -30,6 +37,51 @@ export type ProjectListParams = {
query?: string;
};
+export type GroupFilter = {
+ query?: string;
+ project?: string;
+};
+
+export type AccountFilter = {
+ query?: string;
+ state?: State;
+};
+
+export type ListServiceAccountsParams = {
+ parent: string;
+ pageSize: number;
+ pageToken?: string;
+ showDeleted: boolean;
+ filter?: AccountFilter;
+};
+
+export type ListWorkloadIdentitiesParams = {
+ parent: string;
+ pageSize: number;
+ pageToken?: string;
+ showDeleted: boolean;
+ filter?: AccountFilter;
+};
+
+export type AccessGrantFilter = {
+ name?: string;
+ statement?: string;
+ creator?: string;
+ status?: AccessGrantFilterStatus[];
+ issue?: string;
+ target?: string;
+ createdTsAfter?: number;
+ createdTsBefore?: number;
+};
+
+export type ListAccessGrantsParams = {
+ parent: string;
+ filter?: AccessGrantFilter;
+ pageSize?: number;
+ pageToken?: string;
+ orderBy?: string;
+};
+
export type AuthSlice = {
currentUser?: User;
currentUserRequest?: Promise<User | undefined>;
@@ -172,6 +224,116 @@ export type InstanceRoleSlice = {
fetchInstanceRoles: (instance: string) => Promise<InstanceRole[]>;
};
+export type GroupSlice = {
+ groupsByName: Record<string, Group>;
+ groupRequests: Record<string, Promise<Group | undefined>>;
+ groupErrorsByName: Record<string, Error | undefined>;
+ listGroups: (params: {
+ pageSize: number;
+ pageToken?: string;
+ filter?: GroupFilter;
+ }) => Promise<{ groups: Group[]; nextPageToken: string }>;
+ batchFetchGroups: (names: string[]) => Promise<Group[]>;
+ batchGetOrFetchGroups: (names: string[]) => Promise<(Group | undefined)[]>;
+ fetchGroup: (id: string) => Promise<Group | undefined>;
+ getGroupByIdentifier: (id: string) => Group | undefined;
+ createGroup: (group: Group) => Promise<Group>;
+ updateGroup: (group: Group) => Promise<Group>;
+ deleteGroup: (name: string) => Promise<void>;
+};
+
+export type ServiceAccountSlice = {
+ serviceAccountsByName: Record<string, ServiceAccount>;
+ serviceAccountRequests: Record<string, Promise<ServiceAccount | undefined>>;
+ listServiceAccounts: (
+ params: ListServiceAccountsParams
+ ) => Promise<{ serviceAccounts: ServiceAccount[]; nextPageToken: string }>;
+ fetchServiceAccount: (
+ name: string,
+ silent?: boolean
+ ) => Promise<ServiceAccount | undefined>;
+ getServiceAccount: (name: string) => ServiceAccount;
+ createServiceAccount: (
+ serviceAccountId: string,
+ serviceAccount: Partial<ServiceAccount>,
+ parent: string
+ ) => Promise<ServiceAccount>;
+ updateServiceAccount: (
+ serviceAccount: Partial<ServiceAccount>,
+ updateMask: { paths: string[] }
+ ) => Promise<ServiceAccount>;
+ deleteServiceAccount: (name: string) => Promise<void>;
+ undeleteServiceAccount: (name: string) => Promise<ServiceAccount>;
+};
+
+export type WorkloadIdentitySlice = {
+ workloadIdentitiesByName: Record<string, WorkloadIdentity>;
+ workloadIdentityRequests: Record<
+ string,
+ Promise<WorkloadIdentity | undefined>
+ >;
+ listWorkloadIdentities: (params: ListWorkloadIdentitiesParams) => Promise<{
+ workloadIdentities: WorkloadIdentity[];
+ nextPageToken: string;
+ }>;
+ fetchWorkloadIdentity: (
+ name: string,
+ silent?: boolean
+ ) => Promise<WorkloadIdentity | undefined>;
+ getWorkloadIdentity: (name: string) => WorkloadIdentity;
+ createWorkloadIdentity: (
+ workloadIdentityId: string,
+ workloadIdentity: Partial<WorkloadIdentity>,
+ parent: string
+ ) => Promise<WorkloadIdentity>;
+ updateWorkloadIdentity: (
+ workloadIdentity: Partial<WorkloadIdentity>,
+ updateMask: { paths: string[] }
+ ) => Promise<WorkloadIdentity>;
+ deleteWorkloadIdentity: (name: string) => Promise<void>;
+ undeleteWorkloadIdentity: (name: string) => Promise<WorkloadIdentity>;
+};
+
+export type IdentityProviderSlice = {
+ identityProvidersByName: Record<string, IdentityProvider>;
+ identityProviderRequests: Record<
+ string,
+ Promise<IdentityProvider | undefined>
+ >;
+ identityProviderList: () => IdentityProvider[];
+ listIdentityProviders: (parent?: string) => Promise<IdentityProvider[]>;
+ fetchIdentityProvider: (
+ name: string,
+ silent?: boolean
+ ) => Promise<IdentityProvider | undefined>;
+ getIdentityProvider: (name: string) => IdentityProvider | undefined;
+ createIdentityProvider: (
+ identityProvider: IdentityProvider
+ ) => Promise<IdentityProvider>;
+ updateIdentityProvider: (
+ update: Partial<IdentityProvider>
+ ) => Promise<IdentityProvider>;
+ deleteIdentityProvider: (name: string) => Promise<void>;
+};
+
+export type AccessGrantSlice = {
+ accessGrantsByName: Record<string, AccessGrant>;
+ accessGrantRequests: Record<string, Promise<AccessGrant | undefined>>;
+ fetchAccessGrant: (name: string) => Promise<AccessGrant | undefined>;
+ searchMyAccessGrants: (
+ params: ListAccessGrantsParams
+ ) => Promise<{ accessGrants: AccessGrant[]; nextPageToken: string }>;
+ listAccessGrants: (
+ params: ListAccessGrantsParams
+ ) => Promise<{ accessGrants: AccessGrant[]; nextPageToken: string }>;
+ createAccessGrant: (
+ parent: string,
+ accessGrant: AccessGrant
+ ) => Promise<AccessGrant>;
+ activateAccessGrant: (name: string) => Promise<AccessGrant>;
+ revokeAccessGrant: (name: string) => Promise<AccessGrant>;
+};
+
export type NotificationSlice = {
notify: (notification: NotificationCreate) => void;
};
@@ -192,6 +354,11 @@ export type AppStoreState = AuthSlice &
DBGroupSlice &
SheetSlice &
InstanceRoleSlice &
+ GroupSlice &
+ ServiceAccountSlice &
+ WorkloadIdentitySlice &
+ IdentityProviderSlice &
+ AccessGrantSlice &
NotificationSlice &
PreferencesSlice;
diff --git a/frontend/src/react/stores/app/utils.ts b/frontend/src/react/stores/app/utils.ts
index 0e6256ac99..5872e894db 100644
--- a/frontend/src/react/stores/app/utils.ts
+++ b/frontend/src/react/stores/app/utils.ts
@@ -106,6 +106,10 @@ export function isConnectAlreadyExists(error: unknown): error is ConnectError {
return error instanceof ConnectError && error.code === Code.AlreadyExists;
}
+export function toError(error: unknown): Error {
+ return error instanceof Error ? error : new Error(String(error));
+}
+
export function projectResourceNameFromId(projectId: string | undefined) {
return projectId ? `${projectNamePrefix}${projectId}` : "";
}
diff --git a/frontend/src/react/stores/app/workloadIdentity.ts b/frontend/src/react/stores/app/workloadIdentity.ts
new file mode 100644
index 0000000000..0e1112a766
--- /dev/null
+++ b/frontend/src/react/stores/app/workloadIdentity.ts
@@ -0,0 +1,206 @@
+import { create as createProto } from "@bufbuild/protobuf";
+import { createContextValues } from "@connectrpc/connect";
+import { workloadIdentityServiceClientConnect } from "@/connect";
+import { silentContextKey } from "@/connect/context-key";
+import { State } from "@/types/proto-es/v1/common_pb";
+import { type User, UserSchema } from "@/types/proto-es/v1/user_service_pb";
+import type { WorkloadIdentity } from "@/types/proto-es/v1/workload_identity_service_pb";
+import {
+ CreateWorkloadIdentityRequestSchema,
+ DeleteWorkloadIdentityRequestSchema,
+ GetWorkloadIdentityRequestSchema,
+ ListWorkloadIdentitiesRequestSchema,
+ UndeleteWorkloadIdentityRequestSchema,
+ UpdateWorkloadIdentityRequestSchema,
+ WorkloadIdentitySchema,
+} from "@/types/proto-es/v1/workload_identity_service_pb";
+import { buildAccountListFilter } from "./serviceAccount";
+import type { AppSliceCreator, WorkloadIdentitySlice } from "./types";
+
+const workloadIdentityNamePrefix = "workloadIdentities/";
+
+export const extractWorkloadIdentityId = (identifier: string) => {
+ const matches = identifier.match(
+ /^(?:workloadIdentity:|workloadIdentities\/)(.+)$/
+ );
+ return matches?.[1] ?? identifier;
+};
+
+export const ensureWorkloadIdentityFullName = (identifier: string) => {
+ const id = extractWorkloadIdentityId(identifier);
+ return `${workloadIdentityNamePrefix}${id}`;
+};
+
+export const workloadIdentityToUser = (wi: WorkloadIdentity): User => {
+ return createProto(UserSchema, {
+ name: `users/${wi.email}`,
+ email: wi.email,
+ title: wi.title,
+ state: wi.state,
+ });
+};
+
+export const createWorkloadIdentitySlice: AppSliceCreator<
+ WorkloadIdentitySlice
+> = (set, get) => ({
+ workloadIdentitiesByName: {},
+ workloadIdentityRequests: {},
+
+ listWorkloadIdentities: async (params) => {
+ const response =
+ await workloadIdentityServiceClientConnect.listWorkloadIdentities(
+ createProto(ListWorkloadIdentitiesRequestSchema, {
+ parent: params.parent,
+ pageSize: params.pageSize,
+ pageToken: params.pageToken,
+ showDeleted: params.showDeleted,
+ filter: buildAccountListFilter(params.filter ?? {}),
+ })
+ );
+ set((state) => ({
+ workloadIdentitiesByName: {
+ ...state.workloadIdentitiesByName,
+ ...Object.fromEntries(
+ response.workloadIdentities.map((wi) => [wi.name, wi])
+ ),
+ },
+ }));
+ return {
+ workloadIdentities: response.workloadIdentities,
+ nextPageToken: response.nextPageToken,
+ };
+ },
+
+ fetchWorkloadIdentity: async (name, silent = false) => {
+ const validName = ensureWorkloadIdentityFullName(name);
+ const existing = get().workloadIdentitiesByName[validName];
+ if (existing) return existing;
+ const pending = get().workloadIdentityRequests[validName];
+ if (pending) return pending;
+
+ const request = workloadIdentityServiceClientConnect
+ .getWorkloadIdentity(
+ createProto(GetWorkloadIdentityRequestSchema, { name: validName }),
+ { contextValues: createContextValues().set(silentContextKey, silent) }
+ )
+ .then((workloadIdentity) => {
+ set((state) => {
+ const { [validName]: _, ...workloadIdentityRequests } =
+ state.workloadIdentityRequests;
+ return {
+ workloadIdentitiesByName: {
+ ...state.workloadIdentitiesByName,
+ [workloadIdentity.name]: workloadIdentity,
+ },
+ workloadIdentityRequests,
+ };
+ });
+ return workloadIdentity;
+ })
+ .catch(() => {
+ set((state) => {
+ const { [validName]: _, ...workloadIdentityRequests } =
+ state.workloadIdentityRequests;
+ return { workloadIdentityRequests };
+ });
+ return undefined;
+ });
+ set((state) => ({
+ workloadIdentityRequests: {
+ ...state.workloadIdentityRequests,
+ [validName]: request,
+ },
+ }));
+ return request;
+ },
+
+ getWorkloadIdentity: (name) => {
+ const validName = ensureWorkloadIdentityFullName(name);
+ const email = extractWorkloadIdentityId(validName);
+ return (
+ get().workloadIdentitiesByName[validName] ??
+ createProto(WorkloadIdentitySchema, {
+ name: validName,
+ email,
+ state: State.ACTIVE,
+ title: email.split("@")[0],
+ })
+ );
+ },
+
+ createWorkloadIdentity: async (
+ workloadIdentityId,
+ workloadIdentity,
+ parent
+ ) => {
+ const wi =
+ await workloadIdentityServiceClientConnect.createWorkloadIdentity(
+ createProto(CreateWorkloadIdentityRequestSchema, {
+ parent,
+ workloadIdentityId,
+ workloadIdentity: createProto(
+ WorkloadIdentitySchema,
+ workloadIdentity as WorkloadIdentity
+ ),
+ })
+ );
+ set((state) => ({
+ workloadIdentitiesByName: {
+ ...state.workloadIdentitiesByName,
+ [wi.name]: wi,
+ },
+ }));
+ return wi;
+ },
+
+ updateWorkloadIdentity: async (workloadIdentity, updateMask) => {
+ const wi =
+ await workloadIdentityServiceClientConnect.updateWorkloadIdentity(
+ createProto(UpdateWorkloadIdentityRequestSchema, {
+ workloadIdentity: createProto(
+ WorkloadIdentitySchema,
+ workloadIdentity as WorkloadIdentity
+ ),
+ updateMask,
+ })
+ );
+ set((state) => ({
+ workloadIdentitiesByName: {
+ ...state.workloadIdentitiesByName,
+ [wi.name]: wi,
+ },
+ }));
+ return wi;
+ },
+
+ deleteWorkloadIdentity: async (name) => {
+ const validName = ensureWorkloadIdentityFullName(name);
+ await workloadIdentityServiceClientConnect.deleteWorkloadIdentity(
+ createProto(DeleteWorkloadIdentityRequestSchema, { name: validName })
+ );
+ set((state) => {
+ const cached = state.workloadIdentitiesByName[validName];
+ if (!cached) return {};
+ return {
+ workloadIdentitiesByName: {
+ ...state.workloadIdentitiesByName,
+ [validName]: { ...cached, state: State.DELETED },
+ },
+ };
+ });
+ },
+
+ undeleteWorkloadIdentity: async (name) => {
+ const wi =
+ await workloadIdentityServiceClientConnect.undeleteWorkloadIdentity(
+ createProto(UndeleteWorkloadIdentityRequestSchema, { name })
+ );
+ set((state) => ({
+ workloadIdentitiesByName: {
+ ...state.workloadIdentitiesByName,
+ [wi.name]: wi,
+ },
+ }));
+ return wi;
+ },
+});
diff --git a/frontend/src/store/modules/accessGrant.ts b/frontend/src/store/modules/accessGrant.ts
deleted file mode 100644
index c91d133e7f..0000000000
--- a/frontend/src/store/modules/accessGrant.ts
+++ /dev/null
@@ -1,151 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import { defineStore } from "pinia";
-import { accessGrantServiceClientConnect } from "@/connect";
-import type { AccessGrant } from "@/types/proto-es/v1/access_grant_service_pb";
-import {
- AccessGrant_Status,
- ActivateAccessGrantRequestSchema,
- CreateAccessGrantRequestSchema,
- GetAccessGrantRequestSchema,
- ListAccessGrantsRequestSchema,
- RevokeAccessGrantRequestSchema,
- SearchMyAccessGrantsRequestSchema,
-} from "@/types/proto-es/v1/access_grant_service_pb";
-import { type AccessGrantFilterStatus } from "@/utils";
-
-export interface AccessFilter {
- name?: string;
- statement?: string;
- creator?: string;
- status?: AccessGrantFilterStatus[];
- issue?: string;
- target?: string;
- createdTsAfter?: number;
- createdTsBefore?: number;
-}
-
-const getListAccessFilter = (filter: AccessFilter | undefined): string => {
- if (!filter) return "";
- const parts: string[] = [];
-
- if (filter.name) {
- parts.push(`name == "${filter.name}"`);
- }
- if (filter.status !== undefined && filter.status.length > 0) {
- const statusFilter: string[] = [];
- for (const status of filter.status) {
- switch (status) {
- case "ACTIVE":
- statusFilter.push(
- `(status == "${AccessGrant_Status[AccessGrant_Status.ACTIVE]}" && expire_time > "${new Date().toISOString()}")`
- );
- break;
- case "EXPIRED":
- statusFilter.push(`expire_time <= "${new Date().toISOString()}"`);
- break;
- default:
- statusFilter.push(
- `status == "${status as keyof typeof AccessGrant_Status}"`
- );
- }
- }
- parts.push(`(${statusFilter.join(" || ")})`);
- }
- if (filter.statement) {
- parts.push(`query.contains("${filter.statement.trim()}")`);
- }
- if (filter.creator) {
- parts.push(`creator == "${filter.creator}"`);
- }
- if (filter.issue) {
- parts.push(`issue == "${filter.issue}"`);
- }
- if (filter.target) {
- parts.push(`target == "${filter.target}"`);
- }
- if (filter.createdTsAfter !== undefined) {
- parts.push(
- `create_time >= "${new Date(filter.createdTsAfter).toISOString()}"`
- );
- }
- if (filter.createdTsBefore !== undefined) {
- parts.push(
- `create_time <= "${new Date(filter.createdTsBefore).toISOString()}"`
- );
- }
-
- return parts.join(" && ");
-};
-
-interface ListAccessGrantsParams {
- parent: string;
- filter?: AccessFilter;
- pageSize?: number;
- pageToken?: string;
- orderBy?: string;
-}
-
-export const useAccessGrantStore = defineStore("accessGrant", () => {
- const getAccessGrant = async (name: string) => {
- return await accessGrantServiceClientConnect.getAccessGrant(
- create(GetAccessGrantRequestSchema, { name })
- );
- };
-
- const searchMyAccessGrants = async (params: ListAccessGrantsParams) => {
- return await accessGrantServiceClientConnect.searchMyAccessGrants(
- create(SearchMyAccessGrantsRequestSchema, {
- parent: params.parent,
- filter: getListAccessFilter(params.filter),
- pageSize: params.pageSize ?? 0,
- pageToken: params.pageToken ?? "",
- orderBy: params.orderBy ?? "",
- })
- );
- };
-
- const createAccessGrant = async (
- parent: string,
- accessGrant: AccessGrant
- ) => {
- return await accessGrantServiceClientConnect.createAccessGrant(
- create(CreateAccessGrantRequestSchema, {
- parent,
- accessGrant,
- })
- );
- };
-
- const listAccessGrants = async (params: ListAccessGrantsParams) => {
- return await accessGrantServiceClientConnect.listAccessGrants(
- create(ListAccessGrantsRequestSchema, {
- parent: params.parent,
- filter: getListAccessFilter(params.filter),
- pageSize: params.pageSize ?? 0,
- pageToken: params.pageToken ?? "",
- orderBy: params.orderBy ?? "",
- })
- );
- };
-
- const activateAccessGrant = async (name: string) => {
- return await accessGrantServiceClientConnect.activateAccessGrant(
- create(ActivateAccessGrantRequestSchema, { name })
- );
- };
-
- const revokeAccessGrant = async (name: string) => {
- return await accessGrantServiceClientConnect.revokeAccessGrant(
- create(RevokeAccessGrantRequestSchema, { name })
- );
- };
-
- return {
- getAccessGrant,
- searchMyAccessGrants,
- createAccessGrant,
- listAccessGrants,
- activateAccessGrant,
- revokeAccessGrant,
- };
-});
diff --git a/frontend/src/store/modules/idp.ts b/frontend/src/store/modules/idp.ts
deleted file mode 100644
index 30d7410a0f..0000000000
--- a/frontend/src/store/modules/idp.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import { clone, create } from "@bufbuild/protobuf";
-import { createContextValues } from "@connectrpc/connect";
-import { isEqual, isUndefined } from "lodash-es";
-import { defineStore } from "pinia";
-import { computed, ref } from "vue";
-import { identityProviderServiceClientConnect } from "@/connect";
-import { silentContextKey } from "@/connect/context-key";
-import type { IdentityProvider } from "@/types/proto-es/v1/idp_service_pb";
-import {
- CreateIdentityProviderRequestSchema,
- DeleteIdentityProviderRequestSchema,
- GetIdentityProviderRequestSchema,
- IdentityProviderSchema,
- ListIdentityProvidersRequestSchema,
- UpdateIdentityProviderRequestSchema,
-} from "@/types/proto-es/v1/idp_service_pb";
-
-export const useIdentityProviderStore = defineStore("idp", () => {
- const identityProviderMapByName = ref(new Map<string, IdentityProvider>());
-
- const identityProviderList = computed(() => {
- return Array.from(identityProviderMapByName.value.values());
- });
-
- const fetchIdentityProviderList = async (parent?: string) => {
- const request = create(ListIdentityProvidersRequestSchema, {
- parent: parent ?? "",
- });
- const response =
- await identityProviderServiceClientConnect.listIdentityProviders(request);
- identityProviderMapByName.value.clear();
- for (const identityProvider of response.identityProviders) {
- identityProviderMapByName.value.set(
- identityProvider.name,
- identityProvider
- );
- }
- return response.identityProviders;
- };
-
- const getOrFetchIdentityProviderByName = async (
- name: string,
- silent = false
- ) => {
- const cachedData = identityProviderMapByName.value.get(name);
- if (cachedData) {
- return cachedData;
- }
- const request = create(GetIdentityProviderRequestSchema, { name });
- const identityProvider =
- await identityProviderServiceClientConnect.getIdentityProvider(request, {
- contextValues: createContextValues().set(silentContextKey, silent),
- });
- identityProviderMapByName.value.set(
- identityProvider.name,
- identityProvider
- );
- return identityProvider;
- };
-
- const getIdentityProviderByName = (name: string) => {
- return identityProviderMapByName.value.get(name);
- };
-
- const createIdentityProvider = async (createProvider: IdentityProvider) => {
- const request = create(CreateIdentityProviderRequestSchema, {
- identityProvider: createProvider,
- identityProviderId: createProvider.name,
- });
- const identityProvider =
- await identityProviderServiceClientConnect.createIdentityProvider(
- request
- );
- identityProviderMapByName.value.set(
- identityProvider.name,
- identityProvider
- );
- return identityProvider;
- };
-
- const patchIdentityProvider = async (update: Partial<IdentityProvider>) => {
- const originData = await getOrFetchIdentityProviderByName(
- update.name || ""
- );
- if (!originData) {
- throw new Error(`identity provider with name ${update.name} not found`);
- }
-
- const fullProvider = clone(IdentityProviderSchema, originData);
- if (update.title !== undefined) fullProvider.title = update.title;
- if (update.domain !== undefined) fullProvider.domain = update.domain;
- if (update.type !== undefined) fullProvider.type = update.type;
- if (update.config !== undefined) fullProvider.config = update.config;
- const request = create(UpdateIdentityProviderRequestSchema, {
- identityProvider: fullProvider,
- updateMask: {
- paths: getUpdateMaskFromIdentityProviders(originData, update),
- },
- });
- const identityProvider =
- await identityProviderServiceClientConnect.updateIdentityProvider(
- request
- );
- identityProviderMapByName.value.set(
- identityProvider.name,
- identityProvider
- );
- return identityProvider;
- };
-
- const deleteIdentityProvider = async (name: string) => {
- const request = create(DeleteIdentityProviderRequestSchema, { name });
- await identityProviderServiceClientConnect.deleteIdentityProvider(request);
- identityProviderMapByName.value.delete(name);
- };
-
- return {
- identityProviderMapByName,
- identityProviderList,
- fetchIdentityProviderList,
- getOrFetchIdentityProviderByName,
- getIdentityProviderByName,
- createIdentityProvider,
- patchIdentityProvider,
- deleteIdentityProvider,
- };
-});
-
-const getUpdateMaskFromIdentityProviders = (
- origin: IdentityProvider,
- update: Partial<IdentityProvider>
-): string[] => {
- const updateMask: string[] = [];
- if (!isUndefined(update.title) && !isEqual(origin.title, update.title)) {
- updateMask.push("title");
- }
- if (!isUndefined(update.domain) && !isEqual(origin.domain, update.domain)) {
- updateMask.push("domain");
- }
- if (!isUndefined(update.config) && !isEqual(origin.config, update.config)) {
- updateMask.push("config");
- }
- return updateMask;
-};
diff --git a/frontend/src/store/modules/index.ts b/frontend/src/store/modules/index.ts
index 46c8ca2dd3..a334a08719 100644
--- a/frontend/src/store/modules/index.ts
+++ b/frontend/src/store/modules/index.ts
@@ -1,10 +1,8 @@
-export * from "./accessGrant";
export * from "./v1/auth";
export * from "./notification";
export * from "./router";
export * from "./uistate";
export * from "./sqlReview";
-export * from "./idp";
export * from "./user";
export * from "./serviceAccount";
export * from "./workloadIdentity";
diff --git a/frontend/src/utils/v1/iam.ts b/frontend/src/utils/v1/iam.ts
index e9efcc1516..ce49b32b0c 100644
--- a/frontend/src/utils/v1/iam.ts
+++ b/frontend/src/utils/v1/iam.ts
@@ -18,6 +18,7 @@ import {
serviceAccountBindingPrefix,
workloadIdentityBindingPrefix,
} from "@/types";
+import type { Group } from "@/types/proto-es/v1/group_service_pb";
import type { Binding, IamPolicy } from "@/types/proto-es/v1/iam_policy_pb";
import { ensureUserFullName } from "@/utils";
import { convertFromExpr } from "@/utils/issue/cel";
@@ -59,15 +60,22 @@ export const convertMemberToFullname = (member: string) => {
export const getUserListInBinding = ({
binding,
ignoreGroup,
+ getGroupByIdentifier,
}: {
binding: Binding;
ignoreGroup: boolean;
+ // Resolves a group from its binding member string. Defaults to the Pinia
+ // group store; React callers pass a resolver backed by the app store so
+ // group expansion reads from the same cache they populate.
+ getGroupByIdentifier?: (identifier: string) => Group | undefined;
}): string[] => {
if (isBindingPolicyExpired(binding)) {
return [];
}
- const groupStore = useGroupStore();
+ const resolveGroup =
+ getGroupByIdentifier ??
+ ((identifier: string) => useGroupStore().getGroupByIdentifier(identifier));
const fullnameList = [];
for (const member of binding.members) {
@@ -76,7 +84,7 @@ export const getUserListInBinding = ({
if (ignoreGroup) {
continue;
}
- const group = groupStore.getGroupByIdentifier(member);
+ const group = resolveGroup(member);
if (!group) {
continue;
}
@@ -95,7 +103,8 @@ export const getUserListInBinding = ({
// the user could includes users/ALL_USERS_USER_EMAIL
export const memberMapToRolesInProjectIAM = (
iamPolicy: IamPolicy,
- targetRole?: string
+ targetRole?: string,
+ getGroupByIdentifier?: (identifier: string) => Group | undefined
): Map<string, Set<string>> => {
const workspaceStore = useWorkspaceV1Store();
// Map<userfullname, Set<roles/{role}>>
@@ -110,7 +119,11 @@ export const memberMapToRolesInProjectIAM = (
continue;
}
- const fullnames = getUserListInBinding({ binding, ignoreGroup: false });
+ const fullnames = getUserListInBinding({
+ binding,
+ ignoreGroup: false,
+ getGroupByIdentifier,
+ });
for (const fullname of fullnames) {
if (!rolesMapByName.has(fullname)) {
rolesMapByName.set(fullname, new Set());