Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.tsxindex 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.tsxindex 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.tsxindex 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.tsxindex 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 changesdiff --git a/frontend/src/react/hooks/useAppState.ts b/frontend/src/react/hooks/useAppState.tsindex 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.tsindex 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.tsxindex 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.tsxindex 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 thediff --git a/frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx b/frontend/src/react/pages/project/ProjectAccessGrantsPage.tsxindex 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.tsxindex 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 optionsconst [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.tsxindex 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 loadeduseEffect(() => {@@ -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.tsxindex 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.tsxindex 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.tsxindex 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.tsxindex 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.tsxindex 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 dataconst 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.tsxindex 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 paramsconst 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.tsxindex 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.tsxindex 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 accountsconst 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 accountsconst 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.tsxindex 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 changesuseEffect(() => {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 (<Badgekey={groupName}diff --git a/frontend/src/react/pages/settings/WorkloadIdentitiesPage.tsx b/frontend/src/react/pages/settings/WorkloadIdentitiesPage.tsxindex 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.tsxindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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,getdiff --git a/frontend/src/react/stores/app/serviceAccount.ts b/frontend/src/react/stores/app/serviceAccount.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsdeleted file mode 100644index 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.tsdeleted file mode 100644index 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.tsindex 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.tsindex 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_EMAILexport 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());