Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor(frontend): migrate resource stores to zustand (#20425)
boojackee4434d1f336
diff --git a/docs/superpowers/plans/2026-05-28-react-zustand-resource-phase-2.md b/docs/superpowers/plans/2026-05-28-react-zustand-resource-phase-2.mdnew file mode 100644index 0000000000..3904b41bcd--- /dev/null+++ b/docs/superpowers/plans/2026-05-28-react-zustand-resource-phase-2.md@@ -0,0 +1,1887 @@+# React Zustand Resource Store Migration Phase 2 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:** Move React consumers of User, Role, Release, Revision, Changelog, and ProjectWebhook protobuf resources from legacy Pinia stores to the React Zustand app store.++**Architecture:** Add one focused app-store slice per resource under `frontend/src/react/stores/app/`, register them in `createAppStore`, expose typed actions/selectors in `types.ts`, and migrate React consumers to `useAppStore(selector)`. Keep legacy Pinia stores for Vue consumers, and add a guard test so React cannot re-import the migrated stores.++**Tech Stack:** React, TypeScript, Zustand, Connect RPC generated clients, Vitest, Biome/ESLint.++---++## File Structure++Create:++- `frontend/src/react/stores/app/user.ts`: user cache, list/get/batch/mutation actions, identifier helpers.+- `frontend/src/react/stores/app/role.ts`: role list cache and role mutation actions.+- `frontend/src/react/stores/app/release.ts`: release cache, project list, get/update/delete/undelete actions.+- `frontend/src/react/stores/app/revision.ts`: revision cache, database list/all/get/delete actions.+- `frontend/src/react/stores/app/changelog.ts`: changelog cache keyed by name and view, database list cache, previous changelog lookup.+- `frontend/src/react/stores/app/projectWebhook.ts`: project webhook helper and mutation actions.++Modify:++- `frontend/src/react/stores/app/types.ts`: add resource filter/params and slice types.+- `frontend/src/react/stores/app/index.ts`: import and compose the new slices.+- `frontend/src/react/stores/app/index.test.ts`: add client mocks and focused slice tests.+- `frontend/src/react/hooks/useAppState.ts`: expose small hook facades for migrated resources.+- `frontend/src/react/no-legacy-vue-deps.test.ts`: add the Phase 2 legacy-store guard.+- React consumers currently importing `useUserStore`, `useRoleStore`, `useReleaseStore`, `useRevisionStore`, `useChangelogStore`, and `useProjectWebhookV1Store`.+- Tests for touched consumers that mock the legacy stores.++---++### Task 1: Add User and Role App Store Slices++**Files:**+- Create: `frontend/src/react/stores/app/user.ts`+- Create: `frontend/src/react/stores/app/role.ts`+- Modify: `frontend/src/react/stores/app/types.ts`+- Modify: `frontend/src/react/stores/app/index.ts`+- Modify: `frontend/src/react/stores/app/index.test.ts`++- [ ] **Step 1: Extend app-store types for User and Role**++Add imports in `frontend/src/react/stores/app/types.ts` if they are not already present:++```ts+import type { UpdateUserRequest, User } from "@/types/proto-es/v1/user_service_pb";+import type { Role } from "@/types/proto-es/v1/role_service_pb";+```++Add these types near the existing resource filter types:++```ts+export type UserFilter = {+ query?: string;+ project?: string;+ state?: State;+};++export type ListUsersParams = {+ pageSize: number;+ pageToken?: string;+ filter?: UserFilter;+ showDeleted?: boolean;+};+```++Add these slice types before `NotificationSlice`:++```ts+export type UserSlice = {+ usersByName: Record<string, User>;+ userRequests: Record<string, Promise<User | undefined>>;+ listUsers: (+ params: ListUsersParams+ ) => Promise<{ users: User[]; nextPageToken: string }>;+ fetchUser: (name: string, silent?: boolean) => Promise<User | undefined>;+ batchGetOrFetchUsers: (names: string[]) => Promise<User[]>;+ getOrFetchUserByIdentifier: (params: {+ identifier: string;+ silent?: boolean;+ fallback?: boolean;+ }) => Promise<User>;+ getUserByIdentifier: (identifier: string) => User | undefined;+ createUser: (user: User) => Promise<User>;+ updateUser: (request: UpdateUserRequest) => Promise<User>;+ updateEmail: (oldEmail: string, newEmail: string) => Promise<User>;+ archiveUser: (name: string) => Promise<void>;+ restoreUser: (name: string) => Promise<User>;+};++export type RoleSlice = {+ roleList: Role[];+ listRoles: () => Promise<Role[]>;+ getRoleByName: (name: string) => Role | undefined;+ upsertRole: (role: Role) => Promise<Role>;+ deleteRole: (role: Role) => Promise<void>;+};+```++Extend `AppStoreState`:++```ts+ AccessGrantSlice &+ UserSlice &+ RoleSlice &+ NotificationSlice &+```++- [ ] **Step 2: Create the user slice**++Create `frontend/src/react/stores/app/user.ts`:++```ts+import { create as createProto } from "@bufbuild/protobuf";+import { createContextValues } from "@connectrpc/connect";+import { uniq } from "lodash-es";+import { userServiceClientConnect } from "@/connect";+import { silentContextKey } from "@/connect/context-key";+import {+ allUsersUser,+ isValidProjectName,+ isValidUserName,+ unknownUser,+ userBindingPrefix,+} from "@/types";+import { State } from "@/types/proto-es/v1/common_pb";+import {+ BatchGetUsersRequestSchema,+ CreateUserRequestSchema,+ DeleteUserRequestSchema,+ GetUserRequestSchema,+ ListUsersRequestSchema,+ UndeleteUserRequestSchema,+ UpdateUserRequestSchema,+ type User,+} from "@/types/proto-es/v1/user_service_pb";+import { ensureUserFullName } from "@/utils";+import { isValidProjectName as isValidReactProjectName } from "@/react/lib/resourceName";+import { type AppSliceCreator, type UserFilter, type UserSlice } from "./types";++export const extractUserEmail = (identifier: string) => {+ const matches = identifier.match(/^(?:user:|users\/)(.+)$/);+ return matches?.[1] ?? identifier;+};++export const buildUserFilter = (params: UserFilter) => {+ const filter: string[] = [];+ const search = params.query?.trim()?.toLowerCase();+ if (search) {+ filter.push(`(name.contains("${search}") || email.contains("${search}"))`);+ }+ const project = params.project;+ if (isValidProjectName(project) || isValidReactProjectName(project)) {+ filter.push(`project == "${project}"`);+ }+ if (params.state === State.DELETED) {+ filter.push(`state == "${State[params.state]}"`);+ }+ return filter.join(" && ");+};++const upsertUsers = (+ set: Parameters<AppSliceCreator<UserSlice>>[0],+ users: User[]+) => {+ set((state) => ({+ usersByName: {+ ...state.usersByName,+ ...Object.fromEntries(users.map((user) => [user.name, user])),+ },+ }));+};++export const createUserSlice: AppSliceCreator<UserSlice> = (set, get) => ({+ usersByName: { [allUsersUser().name]: allUsersUser() },+ userRequests: {},++ listUsers: async (params) => {+ if (!get().hasWorkspacePermission("bb.users.list")) {+ return { users: [], nextPageToken: "" };+ }+ const showDeleted =+ params.showDeleted ?? params.filter?.state === State.DELETED;+ const response = await userServiceClientConnect.listUsers(+ createProto(ListUsersRequestSchema, {+ pageSize: params.pageSize,+ pageToken: params.pageToken,+ filter: buildUserFilter(params.filter ?? {}),+ showDeleted,+ })+ );+ upsertUsers(set, response.users);+ return { users: response.users, nextPageToken: response.nextPageToken };+ },++ fetchUser: async (name, silent = false) => {+ const validName = ensureUserFullName(name);+ const existing = get().usersByName[validName];+ if (existing) return existing;+ const pending = get().userRequests[validName];+ if (pending) return pending;+ const request = userServiceClientConnect+ .getUser(createProto(GetUserRequestSchema, { name: validName }), {+ contextValues: createContextValues().set(silentContextKey, silent),+ })+ .then((user) => {+ set((state) => {+ const { [validName]: _, ...userRequests } = state.userRequests;+ return {+ usersByName: { ...state.usersByName, [user.name]: user },+ userRequests,+ };+ });+ return user;+ })+ .catch(() => {+ set((state) => {+ const { [validName]: _, ...userRequests } = state.userRequests;+ return { userRequests };+ });+ return undefined;+ });+ set((state) => ({+ userRequests: { ...state.userRequests, [validName]: request },+ }));+ return request;+ },++ batchGetOrFetchUsers: async (names) => {+ const validNames = uniq(names).filter(+ (name) =>+ Boolean(name) &&+ (name.startsWith("users/") || name.startsWith(userBindingPrefix))+ );+ const missing = validNames+ .map(ensureUserFullName)+ .filter((name) => !get().usersByName[name]);+ if (missing.length > 0) {+ const response = await userServiceClientConnect.batchGetUsers(+ createProto(BatchGetUsersRequestSchema, { names: missing }),+ { contextValues: createContextValues().set(silentContextKey, true) }+ );+ upsertUsers(set, response.users);+ }+ return validNames.map((name) => get().getUserByIdentifier(name) ?? unknownUser(name));+ },++ getOrFetchUserByIdentifier: async ({+ identifier,+ silent = true,+ fallback = true,+ }) => {+ const cached = get().getUserByIdentifier(identifier);+ if (cached) return cached;+ const fullname = ensureUserFullName(identifier);+ if (!isValidUserName(fullname)) {+ return unknownUser();+ }+ const user = await get().fetchUser(fullname, silent);+ if (user) return user;+ return unknownUser(fallback ? fullname : "");+ },++ getUserByIdentifier: (identifier) => {+ const email = extractUserEmail(identifier);+ if (Number.isNaN(Number(email))) {+ return Object.values(get().usersByName).find((user) => user.email === email);+ }+ return get().usersByName[ensureUserFullName(identifier)];+ },++ createUser: async (user) => {+ const response = await userServiceClientConnect.createUser(+ createProto(CreateUserRequestSchema, { user })+ );+ upsertUsers(set, [response]);+ return response;+ },++ updateUser: async (request) => {+ const name = request.user?.name || "";+ const origin = await get().getOrFetchUserByIdentifier({+ identifier: name,+ fallback: false,+ });+ if (!isValidUserName(origin.name)) {+ throw new Error(`user with name ${name} not found`);+ }+ const response = await userServiceClientConnect.updateUser(+ createProto(UpdateUserRequestSchema, {+ user: request.user,+ updateMask: request.updateMask,+ otpCode: request.otpCode,+ regenerateTempMfaSecret: request.regenerateTempMfaSecret,+ regenerateRecoveryCodes: request.regenerateRecoveryCodes,+ })+ );+ upsertUsers(set, [response]);+ return response;+ },++ updateEmail: async (oldEmail, newEmail) => {+ const origin = await get().getOrFetchUserByIdentifier({+ identifier: oldEmail,+ fallback: false,+ });+ if (!isValidUserName(origin.name)) {+ throw new Error(`user with email ${oldEmail} not found`);+ }+ const response = await userServiceClientConnect.updateEmail({+ name: `users/${oldEmail}`,+ email: newEmail,+ });+ set((state) => {+ const { [origin.name]: _, ...usersByName } = state.usersByName;+ return { usersByName: { ...usersByName, [response.name]: response } };+ });+ return response;+ },++ archiveUser: async (name) => {+ const validName = ensureUserFullName(name);+ await userServiceClientConnect.deleteUser(+ createProto(DeleteUserRequestSchema, { name: validName })+ );+ set((state) => {+ const cached = state.usersByName[validName];+ if (!cached) return {};+ return {+ usersByName: {+ ...state.usersByName,+ [validName]: { ...cached, state: State.DELETED },+ },+ };+ });+ },++ restoreUser: async (name) => {+ const response = await userServiceClientConnect.undeleteUser(+ createProto(UndeleteUserRequestSchema, { name: ensureUserFullName(name) })+ );+ upsertUsers(set, [response]);+ return response;+ },+});+```++- [ ] **Step 3: Create the role slice**++Create `frontend/src/react/stores/app/role.ts`:++```ts+import { create as createProto } from "@bufbuild/protobuf";+import { roleServiceClientConnect } from "@/connect";+import type { Role } from "@/types/proto-es/v1/role_service_pb";+import {+ DeleteRoleRequestSchema,+ ListRolesRequestSchema,+ UpdateRoleRequestSchema,+} from "@/types/proto-es/v1/role_service_pb";+import type { AppSliceCreator, RoleSlice } from "./types";++export const createRoleSlice: AppSliceCreator<RoleSlice> = (set, get) => ({+ roleList: [],++ listRoles: async () => {+ const response = await roleServiceClientConnect.listRoles(+ createProto(ListRolesRequestSchema, {})+ );+ set({ roleList: response.roles });+ return response.roles;+ },++ getRoleByName: (name) => get().roleList.find((role) => role.name === name),++ upsertRole: async (role) => {+ const response = await roleServiceClientConnect.updateRole(+ createProto(UpdateRoleRequestSchema, {+ role,+ updateMask: { paths: ["title", "description", "permissions"] },+ allowMissing: true,+ })+ );+ set((state) => {+ const roleList = [...state.roleList];+ const index = roleList.findIndex((item: Role) => item.name === response.name);+ if (index >= 0) {+ roleList.splice(index, 1, response);+ } else {+ roleList.push(response);+ }+ return { roleList };+ });+ return response;+ },++ deleteRole: async (role) => {+ await roleServiceClientConnect.deleteRole(+ createProto(DeleteRoleRequestSchema, { name: role.name })+ );+ set((state) => ({+ roleList: state.roleList.filter((item) => item.name !== role.name),+ }));+ },+});+```++- [ ] **Step 4: Register user and role slices**++Modify `frontend/src/react/stores/app/index.ts`:++```ts+import { createRoleSlice } from "./role";+import { createUserSlice } from "./user";+```++Add them before notification/preferences:++```ts+ ...createAccessGrantSlice(...args),+ ...createUserSlice(...args),+ ...createRoleSlice(...args),+ ...createNotificationSlice(...args),+```++- [ ] **Step 5: Add focused app-store tests for User and Role**++Modify `frontend/src/react/stores/app/index.test.ts` mocks:++```ts+ listUsers: vi.fn(),+ getUser: vi.fn(),+ batchGetUsers: vi.fn(),+ createUser: vi.fn(),+ updateUser: vi.fn(),+ updateEmail: vi.fn(),+ deleteUser: vi.fn(),+ undeleteUser: vi.fn(),+ updateRole: vi.fn(),+ deleteRole: vi.fn(),+```++Extend the connect mock:++```ts+ roleServiceClientConnect: {+ listRoles: mocks.listRoles,+ updateRole: mocks.updateRole,+ deleteRole: mocks.deleteRole,+ },+ userServiceClientConnect: {+ getCurrentUser: mocks.getCurrentUser,+ listUsers: mocks.listUsers,+ getUser: mocks.getUser,+ batchGetUsers: mocks.batchGetUsers,+ createUser: mocks.createUser,+ updateUser: mocks.updateUser,+ updateEmail: mocks.updateEmail,+ deleteUser: mocks.deleteUser,+ undeleteUser: mocks.undeleteUser,+ },+```++Add tests:++```ts+test("lists and caches users", async () => {+ const store = createAppStore();+ mocks.listUsers.mockResolvedValue({ users: [user], nextPageToken: "next" });+ const result = await store.getState().listUsers({ pageSize: 10 });+ expect(result).toEqual({ users: [user], nextPageToken: "next" });+ expect(store.getState().getUserByIdentifier(user.name)).toEqual(user);+});++test("batch fetches missing users and returns unknown fallback", async () => {+ const store = createAppStore();+ mocks.batchGetUsers.mockResolvedValue({ users: [user] });+ const result = await store+ .getState()+ .batchGetOrFetchUsers([user.name, "users/[email protected]"]);+ expect(result[0]).toEqual(user);+ expect(result[1].name).toBe("users/[email protected]");+});++test("updates user email and removes old cache key", async () => {+ const store = createAppStore();+ mocks.getUser.mockResolvedValue(user);+ const updated = createProto(UserSchema, {+ ...user,+ name: "users/[email protected]",+ email: "[email protected]",+ });+ mocks.updateEmail.mockResolvedValue(updated);+ await store.getState().fetchUser(user.name);+ await store.getState().updateEmail(user.email, updated.email);+ expect(store.getState().usersByName[user.name]).toBeUndefined();+ expect(store.getState().usersByName[updated.name]).toEqual(updated);+});++test("lists, upserts, and deletes roles", async () => {+ const store = createAppStore();+ const role = createProto(RoleSchema, {+ name: "roles/PROJECT_OWNER",+ title: "Project Owner",+ });+ mocks.listRoles.mockResolvedValue({ roles: [role] });+ await store.getState().listRoles();+ expect(store.getState().getRoleByName(role.name)).toEqual(role);+ const updated = createProto(RoleSchema, { ...role, title: "Owner" });+ mocks.updateRole.mockResolvedValue(updated);+ await store.getState().upsertRole(updated);+ expect(store.getState().getRoleByName(role.name)?.title).toBe("Owner");+ mocks.deleteRole.mockResolvedValue({});+ await store.getState().deleteRole(updated);+ expect(store.getState().getRoleByName(role.name)).toBeUndefined();+});+```++- [ ] **Step 6: Run focused app-store tests**++Run:++```bash+pnpm --dir frontend exec vitest run src/react/stores/app/index.test.ts+```++Expected: tests compile and pass. If `User` fallback typing fails, apply the fallback correction from Step 2 and rerun.++- [ ] **Step 7: Commit user and role slices**++```bash+git add frontend/src/react/stores/app/user.ts frontend/src/react/stores/app/role.ts frontend/src/react/stores/app/types.ts frontend/src/react/stores/app/index.ts frontend/src/react/stores/app/index.test.ts+git commit -m "feat(frontend): add user and role app stores"+```++---++### Task 2: Add Release, Revision, Changelog, and ProjectWebhook Slices++**Files:**+- Create: `frontend/src/react/stores/app/release.ts`+- Create: `frontend/src/react/stores/app/revision.ts`+- Create: `frontend/src/react/stores/app/changelog.ts`+- Create: `frontend/src/react/stores/app/projectWebhook.ts`+- Modify: `frontend/src/react/stores/app/types.ts`+- Modify: `frontend/src/react/stores/app/index.ts`+- Modify: `frontend/src/react/stores/app/index.test.ts`++- [ ] **Step 1: Extend app-store types for the four smaller resources**++Add imports to `types.ts`:++```ts+import type {+ Changelog,+ ChangelogView,+ ListChangelogsRequest,+ GetChangelogRequest,+} from "@/types/proto-es/v1/database_service_pb";+import type { Release } from "@/types/proto-es/v1/release_service_pb";+import type { Revision } from "@/types/proto-es/v1/revision_service_pb";+import type { Webhook } from "@/types/proto-es/v1/project_service_pb";+```++Add these slice types before `NotificationSlice`:++```ts+export type ReleaseSlice = {+ releasesByName: Record<string, Release>;+ releaseRequests: Record<string, Promise<Release | undefined>>;+ listReleasesByProject: (+ project: string,+ pagination?: { pageSize?: number; pageToken?: string },+ showDeleted?: boolean,+ filter?: string+ ) => Promise<{ releases: Release[]; nextPageToken: string }>;+ fetchRelease: (name: string, silent?: boolean) => Promise<Release | undefined>;+ getReleasesByProject: (project: string) => Release[];+ getReleaseByName: (name: string) => Release;+ updateRelease: (+ release: Partial<Release>,+ updateMask: string[]+ ) => Promise<Release>;+ deleteRelease: (name: string) => Promise<void>;+ undeleteRelease: (name: string) => Promise<Release>;+};++export type RevisionSlice = {+ revisionsByName: Record<string, Revision>;+ listRevisionsByDatabase: (+ database: string,+ pagination?: { pageSize?: number; pageToken?: string }+ ) => Promise<{ revisions: Revision[]; nextPageToken: string }>;+ listAllRevisionsByDatabase: (+ database: string,+ pagination?: { pageSize?: number }+ ) => Promise<Revision[]>;+ fetchRevision: (name: string) => Promise<Revision | undefined>;+ getRevisionsByDatabase: (database: string) => Revision[];+ getRevisionByName: (name: string) => Revision | undefined;+ deleteRevision: (name: string) => Promise<void>;+};++export type ChangelogSlice = {+ changelogsByCacheKey: Record<string, Changelog>;+ changelogsByDatabase: Record<string, Changelog[]>;+ changelogRequests: Record<string, Promise<Changelog | undefined>>;+ clearChangelogCache: (parent: string) => void;+ listChangelogs: (+ params: Partial<ListChangelogsRequest>+ ) => Promise<{ changelogs: Changelog[]; nextPageToken: string }>;+ getOrFetchChangelogListOfDatabase: (+ database: string,+ pageSize: number,+ view?: ChangelogView+ ) => Promise<Changelog[]>;+ changelogListByDatabase: (database: string) => Changelog[];+ fetchChangelog: (+ params: Partial<GetChangelogRequest>+ ) => Promise<Changelog | undefined>;+ getOrFetchChangelogByName: (+ name: string,+ view?: ChangelogView+ ) => Promise<Changelog | undefined>;+ getChangelogByName: (+ name: string,+ view?: ChangelogView+ ) => Changelog | undefined;+ fetchPreviousChangelog: (name: string) => Promise<Changelog | undefined>;+};++export type ProjectWebhookSlice = {+ getProjectWebhookFromProjectById: (+ project: Project,+ webhookId: string+ ) => Webhook | undefined;+ createProjectWebhook: (project: string, webhook: Webhook) => Promise<Project>;+ updateProjectWebhook: (+ webhook: Webhook,+ updateMask: string[]+ ) => Promise<Project>;+ deleteProjectWebhook: (webhook: Webhook) => Promise<Project>;+ testProjectWebhook: (+ project: Project,+ webhook: Webhook+ ) => Promise<{ error: string }>;+};+```++Extend `AppStoreState`:++```ts+ UserSlice &+ RoleSlice &+ ReleaseSlice &+ RevisionSlice &+ ChangelogSlice &+ ProjectWebhookSlice &+ NotificationSlice &+```++- [ ] **Step 2: Create release slice**++Create `frontend/src/react/stores/app/release.ts`:++```ts+import { create as createProto } from "@bufbuild/protobuf";+import { createContextValues } from "@connectrpc/connect";+import { releaseServiceClientConnect } from "@/connect";+import { silentContextKey } from "@/connect/context-key";+import { isValidReleaseName, unknownRelease } from "@/types";+import { State } from "@/types/proto-es/v1/common_pb";+import type { Release } from "@/types/proto-es/v1/release_service_pb";+import {+ DeleteReleaseRequestSchema,+ GetReleaseRequestSchema,+ ListReleasesRequestSchema,+ ReleaseSchema,+ UndeleteReleaseRequestSchema,+ UpdateReleaseRequestSchema,+} from "@/types/proto-es/v1/release_service_pb";+import type { AppSliceCreator, ReleaseSlice } from "./types";++const upsertReleases = (+ set: Parameters<AppSliceCreator<ReleaseSlice>>[0],+ releases: Release[]+) => {+ set((state) => ({+ releasesByName: {+ ...state.releasesByName,+ ...Object.fromEntries(releases.map((release) => [release.name, release])),+ },+ }));+};++export const createReleaseSlice: AppSliceCreator<ReleaseSlice> = (set, get) => ({+ releasesByName: {},+ releaseRequests: {},++ listReleasesByProject: async (project, pagination, showDeleted, filter) => {+ const response = await releaseServiceClientConnect.listReleases(+ createProto(ListReleasesRequestSchema, {+ parent: project,+ pageSize: pagination?.pageSize,+ pageToken: pagination?.pageToken || "",+ showDeleted: Boolean(showDeleted),+ filter: filter || "",+ })+ );+ upsertReleases(set, response.releases);+ return { releases: response.releases, nextPageToken: response.nextPageToken };+ },++ fetchRelease: async (name, silent = false) => {+ if (!isValidReleaseName(name)) return undefined;+ const existing = get().releasesByName[name];+ if (existing) return existing;+ const pending = get().releaseRequests[name];+ if (pending) return pending;+ const request = releaseServiceClientConnect+ .getRelease(createProto(GetReleaseRequestSchema, { name }), {+ contextValues: createContextValues().set(silentContextKey, silent),+ })+ .then((release) => {+ set((state) => {+ const { [name]: _, ...releaseRequests } = state.releaseRequests;+ return {+ releasesByName: { ...state.releasesByName, [release.name]: release },+ releaseRequests,+ };+ });+ return release;+ })+ .catch(() => undefined);+ set((state) => ({+ releaseRequests: { ...state.releaseRequests, [name]: request },+ }));+ return request;+ },++ getReleasesByProject: (project) =>+ Object.values(get().releasesByName).filter((release) =>+ release.name.startsWith(`${project}/releases/`)+ ),++ getReleaseByName: (name) => get().releasesByName[name] ?? unknownRelease(),++ updateRelease: async (release, updateMask) => {+ const response = await releaseServiceClientConnect.updateRelease(+ createProto(UpdateReleaseRequestSchema, {+ release: { ...createProto(ReleaseSchema, {}), ...release },+ updateMask: { paths: updateMask },+ })+ );+ upsertReleases(set, [response]);+ return response;+ },++ deleteRelease: async (name) => {+ await releaseServiceClientConnect.deleteRelease(+ createProto(DeleteReleaseRequestSchema, { name })+ );+ set((state) => {+ const cached = state.releasesByName[name];+ if (!cached) return {};+ return {+ releasesByName: {+ ...state.releasesByName,+ [name]: { ...cached, state: State.DELETED },+ },+ };+ });+ },++ undeleteRelease: async (name) => {+ const response = await releaseServiceClientConnect.undeleteRelease(+ createProto(UndeleteReleaseRequestSchema, { name })+ );+ upsertReleases(set, [response]);+ return response;+ },+});+```++- [ ] **Step 3: Create revision slice**++Create `frontend/src/react/stores/app/revision.ts`:++```ts+import { create as createProto } from "@bufbuild/protobuf";+import { revisionServiceClientConnect } from "@/connect";+import type { Revision } from "@/types/proto-es/v1/revision_service_pb";+import {+ DeleteRevisionRequestSchema,+ GetRevisionRequestSchema,+ ListRevisionsRequestSchema,+} from "@/types/proto-es/v1/revision_service_pb";+import { revisionNamePrefix } from "@/store/modules/v1/common";+import type { AppSliceCreator, RevisionSlice } from "./types";++const upsertRevisions = (+ set: Parameters<AppSliceCreator<RevisionSlice>>[0],+ revisions: Revision[]+) => {+ set((state) => ({+ revisionsByName: {+ ...state.revisionsByName,+ ...Object.fromEntries(revisions.map((revision) => [revision.name, revision])),+ },+ }));+};++export const createRevisionSlice: AppSliceCreator<RevisionSlice> = (set, get) => ({+ revisionsByName: {},++ listRevisionsByDatabase: async (database, pagination) => {+ const response = await revisionServiceClientConnect.listRevisions(+ createProto(ListRevisionsRequestSchema, {+ parent: database,+ pageSize: pagination?.pageSize,+ pageToken: pagination?.pageToken,+ })+ );+ upsertRevisions(set, response.revisions);+ return { revisions: response.revisions, nextPageToken: response.nextPageToken };+ },++ listAllRevisionsByDatabase: async (database, pagination) => {+ const revisions: Revision[] = [];+ let pageToken = "";+ do {+ const response = await get().listRevisionsByDatabase(database, {+ pageSize: pagination?.pageSize,+ pageToken,+ });+ revisions.push(...response.revisions);+ pageToken = response.nextPageToken;+ } while (pageToken);+ return revisions;+ },++ fetchRevision: async (name) => {+ const existing = get().revisionsByName[name];+ if (existing) return existing;+ const revision = await revisionServiceClientConnect.getRevision(+ createProto(GetRevisionRequestSchema, { name })+ );+ upsertRevisions(set, [revision]);+ return revision;+ },++ getRevisionsByDatabase: (database) =>+ Object.values(get().revisionsByName).filter((revision) =>+ revision.name.startsWith(`${database}/${revisionNamePrefix}`)+ ),++ getRevisionByName: (name) => get().revisionsByName[name],++ deleteRevision: async (name) => {+ await revisionServiceClientConnect.deleteRevision(+ createProto(DeleteRevisionRequestSchema, { name })+ );+ set((state) => {+ const { [name]: _, ...revisionsByName } = state.revisionsByName;+ return { revisionsByName };+ });+ },+});+```++- [ ] **Step 4: Create changelog slice**++Create `frontend/src/react/stores/app/changelog.ts`:++```ts+import { create as createProto } from "@bufbuild/protobuf";+import { databaseServiceClientConnect } from "@/connect";+import { UNKNOWN_ID } from "@/types";+import {+ ChangelogView,+ GetChangelogRequestSchema,+ ListChangelogsRequestSchema,+ type Changelog,+} from "@/types/proto-es/v1/database_service_pb";+import { extractChangelogUID } from "@/utils/v1/changelog";+import type { AppSliceCreator, ChangelogSlice } from "./types";++const cacheKey = (name: string, view: ChangelogView) => `${name}\u0000${view}`;++const upsertChangelogs = (+ set: Parameters<AppSliceCreator<ChangelogSlice>>[0],+ changelogs: Changelog[],+ view: ChangelogView+) => {+ set((state) => ({+ changelogsByCacheKey: {+ ...state.changelogsByCacheKey,+ ...Object.fromEntries(+ changelogs.map((changelog) => [cacheKey(changelog.name, view), changelog])+ ),+ },+ }));+};++export const createChangelogSlice: AppSliceCreator<ChangelogSlice> = (+ set,+ get+) => ({+ changelogsByCacheKey: {},+ changelogsByDatabase: {},+ changelogRequests: {},++ clearChangelogCache: (parent) => {+ set((state) => {+ const { [parent]: _, ...changelogsByDatabase } = state.changelogsByDatabase;+ return { changelogsByDatabase };+ });+ },++ listChangelogs: async (params) => {+ const parent = params.parent;+ if (!parent) throw new Error('"parent" field is required');+ const view = params.view ?? ChangelogView.BASIC;+ const response = await databaseServiceClientConnect.listChangelogs(+ createProto(ListChangelogsRequestSchema, {+ parent,+ pageSize: params.pageSize,+ pageToken: params.pageToken,+ view,+ filter: params.filter,+ })+ );+ set((state) => ({+ changelogsByDatabase: {+ ...state.changelogsByDatabase,+ [parent]: response.changelogs,+ },+ }));+ upsertChangelogs(set, response.changelogs, view);+ return { changelogs: response.changelogs, nextPageToken: response.nextPageToken };+ },++ getOrFetchChangelogListOfDatabase: async (+ database,+ pageSize,+ view = ChangelogView.BASIC+ ) => {+ const existing = get().changelogsByDatabase[database];+ if (existing) return existing;+ const { changelogs } = await get().listChangelogs({+ parent: database,+ pageSize,+ view,+ });+ return changelogs;+ },++ changelogListByDatabase: (database) => get().changelogsByDatabase[database] ?? [],++ fetchChangelog: async (params) => {+ if (!params.name) return undefined;+ const view = params.view ?? ChangelogView.BASIC;+ const changelog = await databaseServiceClientConnect.getChangelog(+ createProto(GetChangelogRequestSchema, {+ name: params.name,+ view,+ })+ );+ upsertChangelogs(set, [changelog], view);+ return changelog;+ },++ getOrFetchChangelogByName: async (name, view = ChangelogView.BASIC) => {+ const uid = extractChangelogUID(name);+ if (!uid || uid === String(UNKNOWN_ID)) return undefined;+ const existing = get().changelogsByCacheKey[cacheKey(name, view)];+ if (existing) return existing;+ const requestKey = cacheKey(name, view);+ const pending = get().changelogRequests[requestKey];+ if (pending) return pending;+ const request = get().fetchChangelog({ name, view });+ set((state) => ({+ changelogRequests: { ...state.changelogRequests, [requestKey]: request },+ }));+ return request;+ },++ getChangelogByName: (name, view) => {+ if (view !== undefined) return get().changelogsByCacheKey[cacheKey(name, view)];+ return (+ get().changelogsByCacheKey[cacheKey(name, ChangelogView.FULL)] ??+ get().changelogsByCacheKey[cacheKey(name, ChangelogView.BASIC)]+ );+ },++ fetchPreviousChangelog: async (name) => {+ const parts = name.split("/changelogs/");+ if (parts.length !== 2) return undefined;+ const database = parts[0];+ const currentUID = extractChangelogUID(name);+ if (!currentUID || currentUID === String(UNKNOWN_ID)) return undefined;+ const { changelogs } = await get().listChangelogs({+ parent: database,+ pageSize: 1000,+ view: ChangelogView.BASIC,+ });+ const index = changelogs.findIndex(+ (changelog) => extractChangelogUID(changelog.name) === currentUID+ );+ if (index === -1 || index === changelogs.length - 1) return undefined;+ return get().getOrFetchChangelogByName(+ changelogs[index + 1].name,+ ChangelogView.FULL+ );+ },+});+```++- [ ] **Step 5: Create project webhook slice**++Create `frontend/src/react/stores/app/projectWebhook.ts`:++```ts+import { create as createProto } from "@bufbuild/protobuf";+import { projectServiceClientConnect } from "@/connect";+import {+ AddWebhookRequestSchema,+ RemoveWebhookRequestSchema,+ TestWebhookRequestSchema,+ UpdateWebhookRequestSchema,+ type Project,+ type Webhook,+} from "@/types/proto-es/v1/project_service_pb";+import { extractProjectWebhookID } from "@/utils";+import type { AppSliceCreator, ProjectWebhookSlice } from "./types";++export const createProjectWebhookSlice: AppSliceCreator<ProjectWebhookSlice> = (+ _set,+ _get+) => ({+ getProjectWebhookFromProjectById: (project: Project, webhookId: string) =>+ project.webhooks.find(+ (webhook: Webhook) => extractProjectWebhookID(webhook.name) === webhookId+ ),++ createProjectWebhook: async (project, webhook) =>+ projectServiceClientConnect.addWebhook(+ createProto(AddWebhookRequestSchema, { project, webhook })+ ),++ updateProjectWebhook: async (webhook, updateMask) =>+ projectServiceClientConnect.updateWebhook(+ createProto(UpdateWebhookRequestSchema, {+ webhook,+ updateMask: { paths: updateMask },+ })+ ),++ deleteProjectWebhook: async (webhook) =>+ projectServiceClientConnect.removeWebhook(+ createProto(RemoveWebhookRequestSchema, { webhook })+ ),++ testProjectWebhook: async (project, webhook) => {+ const response = await projectServiceClientConnect.testWebhook(+ createProto(TestWebhookRequestSchema, {+ project: project.name,+ webhook,+ })+ );+ return { error: response.error };+ },+});+```++- [ ] **Step 6: Register the four smaller slices**++Modify `frontend/src/react/stores/app/index.ts`:++```ts+import { createChangelogSlice } from "./changelog";+import { createProjectWebhookSlice } from "./projectWebhook";+import { createReleaseSlice } from "./release";+import { createRevisionSlice } from "./revision";+```++Add them after role:++```ts+ ...createRoleSlice(...args),+ ...createReleaseSlice(...args),+ ...createRevisionSlice(...args),+ ...createChangelogSlice(...args),+ ...createProjectWebhookSlice(...args),+ ...createNotificationSlice(...args),+```++- [ ] **Step 7: Add app-store tests for the four smaller slices**++Extend `index.test.ts` mocks and connect clients for:++```ts+ listReleases: vi.fn(),+ getRelease: vi.fn(),+ updateRelease: vi.fn(),+ deleteRelease: vi.fn(),+ undeleteRelease: vi.fn(),+ listRevisions: vi.fn(),+ getRevision: vi.fn(),+ deleteRevision: vi.fn(),+ listChangelogs: vi.fn(),+ getChangelog: vi.fn(),+ addWebhook: vi.fn(),+ updateWebhook: vi.fn(),+ removeWebhook: vi.fn(),+ testWebhook: vi.fn(),+```++Add tests:++```ts+test("lists and mutates releases", async () => {+ const store = createAppStore();+ const release = createProto(ReleaseSchema, {+ name: "projects/a/releases/r1",+ title: "R1",+ state: State.ACTIVE,+ });+ mocks.listReleases.mockResolvedValue({ releases: [release], nextPageToken: "" });+ await store.getState().listReleasesByProject("projects/a");+ expect(store.getState().getReleaseByName(release.name)).toEqual(release);+ mocks.deleteRelease.mockResolvedValue({});+ await store.getState().deleteRelease(release.name);+ expect(store.getState().getReleaseByName(release.name).state).toBe(State.DELETED);+});++test("lists all revisions by database", async () => {+ const store = createAppStore();+ const revision = createProto(RevisionSchema, {+ name: "instances/i/databases/d/revisions/1",+ });+ mocks.listRevisions.mockResolvedValueOnce({+ revisions: [revision],+ nextPageToken: "",+ });+ const revisions = await store+ .getState()+ .listAllRevisionsByDatabase("instances/i/databases/d");+ expect(revisions).toEqual([revision]);+ expect(store.getState().getRevisionByName(revision.name)).toEqual(revision);+});++test("caches changelogs by database and view", async () => {+ const store = createAppStore();+ const changelog = createProto(ChangelogSchema, {+ name: "instances/i/databases/d/changelogs/1",+ });+ mocks.listChangelogs.mockResolvedValue({+ changelogs: [changelog],+ nextPageToken: "",+ });+ await store.getState().getOrFetchChangelogListOfDatabase(+ "instances/i/databases/d",+ 100+ );+ expect(+ store.getState().getChangelogByName(changelog.name, ChangelogView.BASIC)+ ).toEqual(changelog);+});++test("runs project webhook operations", async () => {+ const store = createAppStore();+ const webhook = createProto(WebhookSchema, {+ name: "projects/a/webhooks/w1",+ title: "Webhook",+ });+ const project = createProto(ProjectSchema, {+ name: "projects/a",+ webhooks: [webhook],+ });+ expect(store.getState().getProjectWebhookFromProjectById(project, "w1")).toEqual(+ webhook+ );+ mocks.testWebhook.mockResolvedValue({ error: "" });+ await expect(+ store.getState().testProjectWebhook(project, webhook)+ ).resolves.toEqual({ error: "" });+});+```++- [ ] **Step 8: Run app-store tests**++Run:++```bash+pnpm --dir frontend exec vitest run src/react/stores/app/index.test.ts+```++Expected: PASS.++- [ ] **Step 9: Commit smaller resource slices**++```bash+git add frontend/src/react/stores/app/release.ts frontend/src/react/stores/app/revision.ts frontend/src/react/stores/app/changelog.ts frontend/src/react/stores/app/projectWebhook.ts frontend/src/react/stores/app/types.ts frontend/src/react/stores/app/index.ts frontend/src/react/stores/app/index.test.ts+git commit -m "feat(frontend): add release revision changelog webhook app stores"+```++---++### Task 3: Add Hook Facades++**Files:**+- Modify: `frontend/src/react/hooks/useAppState.ts`++- [ ] **Step 1: Add hook facades**++Add these exports near the existing resource hooks in `frontend/src/react/hooks/useAppState.ts`:++```ts+export function useUserByIdentifier(identifier: string | undefined) {+ return useAppStore((state) =>+ identifier ? state.getUserByIdentifier(identifier) : undefined+ );+}++export function useRoleByName(name: string | undefined) {+ return useAppStore((state) =>+ name ? state.getRoleByName(name) : undefined+ );+}++export function useReleaseByName(name: string | undefined) {+ return useAppStore((state) =>+ name ? state.getReleaseByName(name) : undefined+ );+}++export function useRevisionByName(name: string | undefined) {+ return useAppStore((state) =>+ name ? state.getRevisionByName(name) : undefined+ );+}++export function useChangelogByName(name: string | undefined) {+ return useAppStore((state) =>+ name ? state.getChangelogByName(name) : undefined+ );+}+```++- [ ] **Step 2: Run focused hook type coverage**++Run:++```bash+pnpm --dir frontend exec vitest run src/react/stores/app/index.test.ts+```++Expected: PASS.++- [ ] **Step 3: Commit hook facades**++```bash+git add frontend/src/react/hooks/useAppState.ts+git commit -m "feat(frontend): add resource app store hooks"+```++---++### Task 4: Add Legacy Guard and Observe Current Failures++**Files:**+- Modify: `frontend/src/react/no-legacy-vue-deps.test.ts`++- [ ] **Step 1: Add Phase 2 guard**++Append a new test in `frontend/src/react/no-legacy-vue-deps.test.ts`:++```ts+ test("Phase 2 protobuf resource consumers use the React app store", () => {+ const bannedImports = [+ "useUserStore",+ "useRoleStore",+ "useReleaseStore",+ "useRevisionStore",+ "useChangelogStore",+ "useProjectWebhookV1Store",+ "@/store/modules/user",+ "@/store/modules/role",+ "@/store/modules/release",+ "@/store/modules/revision",+ "@/store/modules/v1/changelog",+ "@/store/modules/v1/projectWebhook",+ ];+ 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([]);+ });+```++- [ ] **Step 2: Run guard test and observe expected failure**++Run:++```bash+pnpm --dir frontend exec vitest run src/react/no-legacy-vue-deps.test.ts+```++Expected: FAIL listing current React consumers of the Phase 2 legacy stores. Keep this failing state until Tasks 5-9 migrate the consumers.++- [ ] **Step 3: Keep the guard change uncommitted**++```bash+git diff -- frontend/src/react/no-legacy-vue-deps.test.ts+```++Expected: the diff contains only the Phase 2 guard test. Do not commit this failing guard yet.++---++### Task 5: Migrate User and Role React Consumers++**Files:**+- Modify all non-test React files returned by:+ - `rg -l "useUserStore" frontend/src/react --glob '*.{ts,tsx}' --glob '!**/*.test.ts' --glob '!**/*.test.tsx'`+ - `rg -l "useRoleStore" frontend/src/react --glob '*.{ts,tsx}' --glob '!**/*.test.ts' --glob '!**/*.test.tsx'`+- Modify affected tests that mock `useUserStore` or `useRoleStore`.++- [ ] **Step 1: Replace User store imports**++For each React source importing `useUserStore`, add:++```ts+import { useAppStore } from "@/react/stores/app";+```++Replace:++```ts+const userStore = useUserStore();+```++with only the actions/selectors used in that file. Example for list and cache lookups:++```ts+const listUsers = useAppStore((state) => state.listUsers);+const getUserByIdentifier = useAppStore((state) => state.getUserByIdentifier);+const batchGetOrFetchUsers = useAppStore(+ (state) => state.batchGetOrFetchUsers+);+```++Use these method mappings:++```ts+userStore.fetchUserList(...) -> listUsers(...)+userStore.getUserByIdentifier(...) -> getUserByIdentifier(...)+userStore.getOrFetchUserByIdentifier(...) -> getOrFetchUserByIdentifier(...)+userStore.batchGetOrFetchUsers(...) -> batchGetOrFetchUsers(...)+userStore.createUser(...) -> createUser(...)+userStore.updateUser(...) -> updateUser(...)+userStore.updateEmail(...) -> updateEmail(...)+userStore.archiveUser(...) -> archiveUser(...)+userStore.restoreUser(...) -> restoreUser(...)+```++For reactive display reads, do not use `useVueState`. Replace patterns like:++```ts+const user = useVueState(() => userStore.getUserByIdentifier(name));+```++with:++```ts+const user = useAppStore((state) => state.getUserByIdentifier(name));+```++- [ ] **Step 2: Replace Role store imports**++For each React source importing `useRoleStore`, add:++```ts+import { useAppStore } from "@/react/stores/app";+```++Replace:++```ts+const roleStore = useRoleStore();+```++with only the actions/selectors used in that file:++```ts+const roleList = useAppStore((state) => state.roleList);+const listRoles = useAppStore((state) => state.listRoles);+const getRoleByName = useAppStore((state) => state.getRoleByName);+const upsertRole = useAppStore((state) => state.upsertRole);+const deleteRole = useAppStore((state) => state.deleteRole);+```++Use these method mappings:++```ts+roleStore.roleList -> roleList+roleStore.fetchRoleList() -> listRoles()+roleStore.getRoleByName(name) -> getRoleByName(name)+roleStore.upsertRole(role) -> upsertRole(role)+roleStore.deleteRole(role) -> deleteRole(role)+```++- [ ] **Step 3: Update tests for User and Role consumers**++For tests mocking `@/store` with `useUserStore` or `useRoleStore`, remove those keys and add:++```ts+vi.mock("@/react/stores/app", () => ({+ useAppStore: (selector: (state: unknown) => unknown) =>+ selector({+ listUsers: mocks.listUsers,+ fetchUser: mocks.fetchUser,+ batchGetOrFetchUsers: mocks.batchGetOrFetchUsers,+ getOrFetchUserByIdentifier: mocks.getOrFetchUserByIdentifier,+ getUserByIdentifier: mocks.getUserByIdentifier,+ createUser: mocks.createUser,+ updateUser: mocks.updateUser,+ updateEmail: mocks.updateEmail,+ archiveUser: mocks.archiveUser,+ restoreUser: mocks.restoreUser,+ roleList: mocks.roleList,+ listRoles: mocks.listRoles,+ getRoleByName: mocks.getRoleByName,+ upsertRole: mocks.upsertRole,+ deleteRole: mocks.deleteRole,+ }),+}));+```++Keep only the functions each test actually needs in its mock object.++- [ ] **Step 4: Verify User and Role imports are gone**++Run:++```bash+rg -n "useUserStore|useRoleStore|@/store/modules/user|@/store/modules/role" frontend/src/react --glob '*.{ts,tsx}' --glob '!no-legacy-vue-deps.test.ts'+```++Expected: no output.++- [ ] **Step 5: Run focused tests**++Run:++```bash+pnpm --dir frontend exec vitest run src/react/stores/app/index.test.ts src/react/no-legacy-vue-deps.test.ts src/react/components/UserSelect.test.tsx src/react/components/RoleSelect.test.tsx src/react/pages/settings/MembersPage.test.tsx src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.test.tsx+```++Expected: tests for already-migrated resources pass; the guard may still fail for Release/Revision/Changelog/ProjectWebhook until Tasks 6-9 complete.++- [ ] **Step 6: Commit User and Role consumers**++```bash+git add frontend/src/react+git commit -m "refactor(frontend): migrate user and role consumers to app store"+```++---++### Task 6: Migrate Release Consumers++**Files:**+- Modify: `frontend/src/react/pages/project/ProjectReleaseDashboardPage.tsx`+- Modify: `frontend/src/react/pages/project/ProjectReleaseDetailPage.tsx`+- Modify: `frontend/src/react/pages/project/database-detail/revision/ImportRevisionSheet.tsx`+- Modify: `frontend/src/react/pages/project/issue-detail/components/IssueDetailStatementSection.tsx`+- Modify: `frontend/src/react/components/task-run-log/useTaskRunLogData.ts`+- Modify affected tests under the same directories.++- [ ] **Step 1: Replace release store imports**++In each release consumer, add:++```ts+import { useAppStore } from "@/react/stores/app";+```++Use these mappings:++```ts+releaseStore.fetchReleasesByProject(...) -> listReleasesByProject(...)+releaseStore.fetchReleaseByName(...) -> fetchRelease(...)+releaseStore.getReleasesByProject(...) -> getReleasesByProject(...)+releaseStore.getReleaseByName(...) -> getReleaseByName(...)+releaseStore.updateRelase(...) -> updateRelease(...)+releaseStore.deleteRelease(...) -> deleteRelease(...)+releaseStore.undeleteRelease(...) -> undeleteRelease(...)+```++Example:++```ts+const listReleasesByProject = useAppStore(+ (state) => state.listReleasesByProject+);+const getReleaseByName = useAppStore((state) => state.getReleaseByName);+```++- [ ] **Step 2: Replace release reactive reads**++Replace:++```ts+const release = useVueState(() => releaseStore.getReleaseByName(name));+```++with:++```ts+const release = useAppStore((state) => state.getReleaseByName(name));+```++- [ ] **Step 3: Update release tests**++For tests mocking `useReleaseStore`, use:++```ts+vi.mock("@/react/stores/app", () => ({+ useAppStore: (selector: (state: unknown) => unknown) =>+ selector({+ listReleasesByProject: mocks.listReleasesByProject,+ fetchRelease: mocks.fetchRelease,+ getReleasesByProject: mocks.getReleasesByProject,+ getReleaseByName: mocks.getReleaseByName,+ updateRelease: mocks.updateRelease,+ deleteRelease: mocks.deleteRelease,+ undeleteRelease: mocks.undeleteRelease,+ }),+}));+```++- [ ] **Step 4: Verify release imports are gone**++Run:++```bash+rg -n "useReleaseStore|@/store/modules/release" frontend/src/react --glob '*.{ts,tsx}' --glob '!no-legacy-vue-deps.test.ts'+```++Expected: no output.++- [ ] **Step 5: Commit release consumers**++```bash+git add frontend/src/react+git commit -m "refactor(frontend): migrate release consumers to app store"+```++---++### Task 7: Migrate Revision Consumers++**Files:**+- Modify: `frontend/src/react/components/revision/RevisionDetailPanel.tsx`+- Modify: `frontend/src/react/pages/project/database-detail/revision/ImportRevisionSheet.tsx`+- Modify: `frontend/src/react/pages/project/database-detail/panels/DatabaseRevisionPanel.tsx`+- Modify affected tests under the same directories.++- [ ] **Step 1: Replace revision store imports**++Add:++```ts+import { useAppStore } from "@/react/stores/app";+```++Use these mappings:++```ts+revisionStore.fetchRevisionsByDatabase(...) -> listRevisionsByDatabase(...)+revisionStore.fetchAllRevisionsByDatabase(...) -> listAllRevisionsByDatabase(...)+revisionStore.getRevisionsByDatabase(...) -> getRevisionsByDatabase(...)+revisionStore.getOrFetchRevisionByName(...) -> fetchRevision(...)+revisionStore.getRevisionByName(...) -> getRevisionByName(...)+revisionStore.deleteRevision(...) -> deleteRevision(...)+```++- [ ] **Step 2: Replace revision reactive reads**++Replace:++```ts+const revision = useVueState(() => revisionStore.getRevisionByName(name));+```++with:++```ts+const revision = useAppStore((state) => state.getRevisionByName(name));+```++- [ ] **Step 3: Verify revision imports are gone**++Run:++```bash+rg -n "useRevisionStore|@/store/modules/revision" frontend/src/react --glob '*.{ts,tsx}' --glob '!no-legacy-vue-deps.test.ts'+```++Expected: no output.++- [ ] **Step 4: Commit revision consumers**++```bash+git add frontend/src/react+git commit -m "refactor(frontend): migrate revision consumers to app store"+```++---++### Task 8: Migrate Changelog Consumers++**Files:**+- Modify: `frontend/src/react/pages/project/DatabaseChangelogDetailPage.tsx`+- Modify: `frontend/src/react/pages/project/ProjectSyncSchemaPage.tsx`+- Modify: `frontend/src/react/pages/project/database-detail/panels/DatabaseChangelogPanel.tsx`+- Modify affected tests under the same directories.++- [ ] **Step 1: Replace changelog store imports**++Add:++```ts+import { useAppStore } from "@/react/stores/app";+```++Use these mappings:++```ts+changelogStore.clearCache(...) -> clearChangelogCache(...)+changelogStore.fetchChangelogList(...) -> listChangelogs(...)+changelogStore.getOrFetchChangelogListOfDatabase(...) -> getOrFetchChangelogListOfDatabase(...)+changelogStore.changelogListByDatabase(...) -> changelogListByDatabase(...)+changelogStore.fetchChangelog(...) -> fetchChangelog(...)+changelogStore.getOrFetchChangelogByName(...) -> getOrFetchChangelogByName(...)+changelogStore.getChangelogByName(...) -> getChangelogByName(...)+changelogStore.fetchPreviousChangelog(...) -> fetchPreviousChangelog(...)+```++- [ ] **Step 2: Replace changelog reactive reads**++Replace:++```ts+const changelog = useVueState(() => changelogStore.getChangelogByName(name));+```++with:++```ts+const changelog = useAppStore((state) => state.getChangelogByName(name));+```++- [ ] **Step 3: Verify changelog imports are gone**++Run:++```bash+rg -n "useChangelogStore|@/store/modules/v1/changelog" frontend/src/react --glob '*.{ts,tsx}' --glob '!no-legacy-vue-deps.test.ts'+```++Expected: no output.++- [ ] **Step 4: Commit changelog consumers**++```bash+git add frontend/src/react+git commit -m "refactor(frontend): migrate changelog consumers to app store"+```++---++### Task 9: Migrate Project Webhook Consumers++**Files:**+- Modify: `frontend/src/react/pages/project/ProjectWebhookForm.tsx`+- Modify: `frontend/src/react/pages/project/ProjectWebhooksPage.tsx`+- Modify: `frontend/src/react/pages/project/ProjectWebhookDetailPage.tsx`+- Modify affected tests under the same directories.++- [ ] **Step 1: Replace project webhook store imports**++Add:++```ts+import { useAppStore } from "@/react/stores/app";+```++Use these mappings:++```ts+projectWebhookStore.getProjectWebhookFromProjectById(...) -> getProjectWebhookFromProjectById(...)+projectWebhookStore.createProjectWebhook(...) -> createProjectWebhook(...)+projectWebhookStore.updateProjectWebhook(...) -> updateProjectWebhook(...)+projectWebhookStore.deleteProjectWebhook(...) -> deleteProjectWebhook(...)+projectWebhookStore.testProjectWebhook(...) -> testProjectWebhook(...)+```++- [ ] **Step 2: Preserve project refresh behavior**++Where callers currently receive an updated `Project` from webhook mutations, keep the existing follow-up behavior. For example:++```ts+const project = await updateProjectWebhook(webhook, updateMask);+projectStore.updateProjectCache?.(project);+```++Use the refresh/update function already present in the current file. For example, if the file currently calls `fetchProject()` after a webhook mutation, keep that call and replace only the project webhook store call.++- [ ] **Step 3: Verify project webhook imports are gone**++Run:++```bash+rg -n "useProjectWebhookV1Store|@/store/modules/v1/projectWebhook" frontend/src/react --glob '*.{ts,tsx}' --glob '!no-legacy-vue-deps.test.ts'+```++Expected: no output.++- [ ] **Step 4: Commit project webhook consumers**++```bash+git add frontend/src/react+git commit -m "refactor(frontend): migrate project webhook consumers to app store"+```++---++### Task 10: Final Guard, Type, and Full Frontend Verification++**Files:**+- Modify only files needed to fix verification failures found in this task.++- [ ] **Step 1: Run legacy import greps**++Run:++```bash+rg -n "useUserStore|useRoleStore|useReleaseStore|useRevisionStore|useChangelogStore|useProjectWebhookV1Store|@/store/modules/user|@/store/modules/role|@/store/modules/release|@/store/modules/revision|@/store/modules/v1/changelog|@/store/modules/v1/projectWebhook" frontend/src/react --glob '*.{ts,tsx}' --glob '!no-legacy-vue-deps.test.ts'+```++Expected: no output.++- [ ] **Step 2: Run focused guard and app-store tests**++Run:++```bash+pnpm --dir frontend exec vitest run src/react/stores/app/index.test.ts src/react/no-legacy-vue-deps.test.ts+```++Expected: PASS.++- [ ] **Step 3: Run formatter/linter fixer**++Run:++```bash+pnpm --dir frontend fix+```++Expected: command exits 0.++- [ ] **Step 4: Run CI-style frontend check**++Run:++```bash+pnpm --dir frontend check+```++Expected: command exits 0.++- [ ] **Step 5: Run React/Vue type check**++Run:++```bash+pnpm --dir frontend type-check+```++Expected: command exits 0.++- [ ] **Step 6: Run full frontend tests**++Run:++```bash+pnpm --dir frontend test+```++Expected: all frontend tests pass.++- [ ] **Step 7: Run whitespace diff check**++Run:++```bash+git diff --check+```++Expected: no output and exit 0.++- [ ] **Step 8: Commit final guard and verification fixes**++When the guard and verification commands pass, commit the guard plus any verification fixes:++```bash+git add frontend/src/react frontend/src/react/stores/app+git commit -m "fix(frontend): complete phase two app store migration"+```++Expected: creates a commit containing `frontend/src/react/no-legacy-vue-deps.test.ts` and any source/test files adjusted during final verification.++---++### Task 11: Prepare Review Summary++**Files:**+- Read-only unless a PR description file is requested separately.++- [ ] **Step 1: Summarize commits**++Run:++```bash+git log --oneline main..HEAD+```++Expected: shows the Phase 2 migration commits on the working branch.++- [ ] **Step 2: Summarize final changed files**++Run:++```bash+git diff --stat main...HEAD+```++Expected: shows app-store slices, migrated consumers, tests, and guard updates.++- [ ] **Step 3: Prepare final handoff**++Report:++```md+Implemented Phase 2 resource store migration.++Resources migrated:+- User+- Role+- Release+- Revision+- Changelog+- ProjectWebhook++Verification:+- pnpm --dir frontend exec vitest run src/react/stores/app/index.test.ts src/react/no-legacy-vue-deps.test.ts+- pnpm --dir frontend fix+- pnpm --dir frontend check+- pnpm --dir frontend type-check+- pnpm --dir frontend test+- git diff --check+```++Use the actual command outcomes from Task 10.diff --git a/docs/superpowers/specs/2026-05-28-react-zustand-resource-phase-2-design.md b/docs/superpowers/specs/2026-05-28-react-zustand-resource-phase-2-design.mdnew file mode 100644index 0000000000..e5f415f225--- /dev/null+++ b/docs/superpowers/specs/2026-05-28-react-zustand-resource-phase-2-design.md@@ -0,0 +1,208 @@+# React Zustand Resource Store Migration Phase 2 Design++## Context++Phase 1 moved the first protobuf resource stores into the React app store and added a guard that prevents React code from re-importing those legacy Pinia stores. The next useful batch is the remaining resource stores with meaningful React usage but bounded API surfaces:++- `User`+- `Role`+- `Release`+- `Revision`+- `Changelog`+- `ProjectWebhook`++This phase keeps the Vue Pinia stores in place for Vue consumers. The goal is to migrate React consumers to `useAppStore` and add guard coverage so React does not regress.++## Goals++- Add Zustand slices under `frontend/src/react/stores/app/` for the six resources.+- Preserve the observable behavior of the current Pinia stores for React callers.+- Migrate all React non-test consumers of the six legacy stores.+- Update affected tests to mock `@/react/stores/app` instead of legacy Pinia stores.+- Extend `frontend/src/react/no-legacy-vue-deps.test.ts` to block these stores from React code.++## Non-Goals++- Do not delete legacy Pinia stores.+- Do not migrate Vue consumers.+- Do not include `Issue`, `Plan`, `Rollout`, `Policy`, `ProjectIamPolicy`, worksheet, or SQL editor legacy store migrations in this phase.+- Do not refactor UI flows beyond the minimum needed for store migration.++## Current React Consumer Surface++Approximate non-test React consumer counts on current `main`:++- `useUserStore`: 20 files+- `useRoleStore`: 10 files+- `useReleaseStore`: 5 files+- `useRevisionStore`: 3 files+- `useChangelogStore`: 3 files+- `useProjectWebhookV1Store`: 3 files++The batch is large enough to be a single focused resource-store PR, but not mixed with lifecycle resources such as `Issue`, `Plan`, and `Rollout`.++## Architecture++Add these files:++- `frontend/src/react/stores/app/user.ts`+- `frontend/src/react/stores/app/role.ts`+- `frontend/src/react/stores/app/release.ts`+- `frontend/src/react/stores/app/revision.ts`+- `frontend/src/react/stores/app/changelog.ts`+- `frontend/src/react/stores/app/projectWebhook.ts`++Update these shared app-store files:++- `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/hooks/useAppState.ts`++Each slice should follow the existing app-store style:++- Store resource maps as plain objects keyed by resource name.+- Store request maps for deduped fetches where the Pinia store currently caches requests.+- Keep list functions as async actions that return API response payloads and upsert entities into cache.+- Use `useAppStore(selector)` for reactive reads in React components.+- Use selected actions from `useAppStore(selector)` for component event handlers.+- Reserve `useAppStore.getState()` for imperative contexts where a hook is not legal.++## Slice Responsibilities++### User++The user slice should cover:++- current app user compatibility where needed by user consumers+- `listUsers`+- `fetchUser`+- `batchGetOrFetchUsers`+- `getOrFetchUserByIdentifier`+- `getUserByIdentifier`+- `createUser`+- `updateUser`+- `updateEmail`+- `archiveUser`+- `restoreUser`++It should preserve the special `allUsersUser()` cache entry and unknown-user fallback behavior used by selectors and tables. It should also invalidate permission cache behavior through app-store permission state if needed, rather than importing the legacy permission Pinia store.++### Role++The role slice should cover:++- `listRoles`+- `getRoleByName`+- `upsertRole`+- `deleteRole`++It should keep the current `allowMissing: true` update behavior and remove deleted roles from the cached list.++### Release++The release slice should cover:++- `listReleasesByProject`+- `fetchRelease`+- `getReleasesByProject`+- `getReleaseByName`+- `updateRelease`+- `deleteRelease`+- `undeleteRelease`++It should preserve deleted release state updates and the unknown-release fallback expected by current UI.++### Revision++The revision slice should cover:++- `listRevisionsByDatabase`+- `listAllRevisionsByDatabase`+- `fetchRevision`+- `getRevisionsByDatabase`+- `getRevisionByName`+- `deleteRevision`++It should keep database-scoped list behavior and support the import-revision and revision panel flows.++### Changelog++The changelog slice should cover:++- `clearChangelogCache`+- `listChangelogs`+- `getOrFetchChangelogListOfDatabase`+- `changelogListByDatabase`+- `fetchChangelog`+- `getOrFetchChangelogByName`+- `getChangelogByName`+- `fetchPreviousChangelog`++The cache key must include `ChangelogView`, preserving the current BASIC/FULL lookup behavior. `getChangelogByName(name)` without a view should continue to prefer FULL and fall back to BASIC.++### ProjectWebhook++The project webhook slice should cover:++- `getProjectWebhookFromProjectById`+- `createProjectWebhook`+- `updateProjectWebhook`+- `deleteProjectWebhook`+- `testProjectWebhook`++The mutation APIs return updated `Project` responses from the backend. Consumer migration should keep the current project refresh/update behavior unchanged.++## Consumer Migration++Migrate all React non-test consumers of these stores:++- User consumers in account selectors, member/user settings, auth profile/setup/reset flows, issue and audit tables, approval flows, SQL editor display labels, masking exemption, access grant pages, and plan/data export dashboards.+- Role consumers in role selectors, roles settings, request-role sheets, custom approval utilities, environment settings, role grant details, setup, and SQL editor request query actions.+- Release consumers in release dashboard/detail, import revision, issue statement section, and task-run log data.+- Revision consumers in revision panel, database revision panel, and import revision.+- Changelog consumers in sync schema, database changelog list/detail, and changelog panels.+- Project webhook consumers in webhook list/detail/form pages.++Tests that currently mock the legacy stores should be updated to mock `@/react/stores/app`.++## Guardrails++Extend `frontend/src/react/no-legacy-vue-deps.test.ts` with a Phase 2 guard that fails if React code imports or references:++- `useUserStore`+- `useRoleStore`+- `useReleaseStore`+- `useRevisionStore`+- `useChangelogStore`+- `useProjectWebhookV1Store`+- direct module imports for the corresponding Pinia store files++The guard should exclude itself and can allow Vue-side Pinia stores to remain untouched.++## Error Handling++Keep current behavior:++- Silent fetches should continue to use `silentContextKey`.+- User not-found paths should preserve existing unknown-user fallback semantics.+- Role deletion should keep graceful-request behavior, either by preserving the same wrapper behavior or by matching its notification/error semantics in callers.+- Changelog invalid or unknown IDs should return `undefined` instead of issuing invalid backend requests.++## Testing++Use focused tests while developing, then run the standard frontend verification:++- `pnpm --dir frontend exec vitest run src/react/stores/app/index.test.ts src/react/no-legacy-vue-deps.test.ts`+- Focused tests for touched consumers that already have coverage.+- `pnpm --dir frontend fix`+- `pnpm --dir frontend check`+- `pnpm --dir frontend type-check`+- `pnpm --dir frontend test`++## Implementation Notes++- Migrate the slices first, then migrate consumers by resource group.+- Prefer small mechanical patches and grep after each group to ensure no React consumer remains.+- Use `useAppStore(selector)` for reactive values; do not wrap `useAppStore.getState()` in `useVueState`.+- Keep generated artifacts out of the commit unless verification commands intentionally update them and they are required.diff --git a/frontend/src/react/components/AccountMultiSelect.tsx b/frontend/src/react/components/AccountMultiSelect.tsxindex dfd4600f21..45849bfed5 100644--- a/frontend/src/react/components/AccountMultiSelect.tsx+++ b/frontend/src/react/components/AccountMultiSelect.tsx@@ -7,7 +7,7 @@ import { useClickOutside } from "@/react/hooks/useClickOutside";import { useVueState } from "@/react/hooks/useVueState";import { cn } from "@/react/lib/utils";import { useAppStore } from "@/react/stores/app";-import { useCurrentUserV1, useUserStore } from "@/store";+import { useCurrentUserV1 } from "@/store";import {extractUserEmail,groupNamePrefix,@@ -192,7 +192,7 @@ export function AccountMultiSelect({includeAllUsers?: boolean;}) {const { t } = useTranslation();- const userStore = useUserStore();+ const listUsers = useAppStore((state) => state.listUsers);const listGroups = useAppStore((state) => state.listGroups);const currentUser = useVueState(() => useCurrentUserV1().value);@@ -212,9 +212,9 @@ export function AccountMultiSelect({if (debounceRef.current) clearTimeout(debounceRef.current);debounceRef.current = setTimeout(() => {const query = search.trim();- userStore- .fetchUserList({ pageSize: getDefaultPagination(), filter: { query } })- .then(({ users: fetched }) => setUsers(fetched));+ listUsers({ pageSize: getDefaultPagination(), filter: { query } }).then(+ ({ users: fetched }) => setUsers(fetched)+ );listGroups({ pageSize: getDefaultPagination(), filter: { query } }).then(({ groups: fetched }) => setGroups(fetched));@@ -222,7 +222,7 @@ export function AccountMultiSelect({return () => {if (debounceRef.current) clearTimeout(debounceRef.current);};- }, [search, userStore, listGroups]);+ }, [search, listUsers, listGroups]);const handleClickOutside = useCallback(() => {setOpen(false);diff --git a/frontend/src/react/components/AuditLogTable.test.tsx b/frontend/src/react/components/AuditLogTable.test.tsxindex ce536fa3b6..d438f4cc08 100644--- a/frontend/src/react/components/AuditLogTable.test.tsx+++ b/frontend/src/react/components/AuditLogTable.test.tsx@@ -21,7 +21,7 @@ const mocks = vi.hoisted(() => ({useTranslation: vi.fn(() => ({ t: (key: string) => key })),pushNotification: vi.fn(),usePlanFeature: vi.fn(() => true),- useUserStore: vi.fn(() => ({ fetchUserList: vi.fn() })),+ listUsers: vi.fn(async () => ({ users: [] })),}));vi.mock("react-i18next", () => ({@@ -37,7 +37,13 @@ vi.mock("@/connect", () => ({vi.mock("@/store", () => ({pushNotification: mocks.pushNotification,- useUserStore: mocks.useUserStore,+}));++vi.mock("@/react/stores/app", () => ({+ useAppStore: (selector: (state: unknown) => unknown) =>+ selector({+ listUsers: mocks.listUsers,+ }),}));vi.mock("@/react/hooks/useAppState", () => ({diff --git a/frontend/src/react/components/AuditLogTable.tsx b/frontend/src/react/components/AuditLogTable.tsxindex 3b95648033..f4f0593a9f 100644--- a/frontend/src/react/components/AuditLogTable.tsx+++ b/frontend/src/react/components/AuditLogTable.tsx@@ -38,7 +38,8 @@ import {useSessionPageSize,} from "@/react/hooks/useSessionPageSize";import { cn } from "@/react/lib/utils";-import { pushNotification, useUserStore } from "@/store";+import { useAppStore } from "@/react/stores/app";+import { pushNotification } from "@/store";import {extractUserEmail,getProjectIdPlanUidStageUidFromRolloutName,@@ -663,11 +664,10 @@ export function AuditLogTable({return t("audit-log.export-tooltip");return "";}, [filter, t]);-- const userStore = useUserStore();+ const listUsers = useAppStore((state) => state.listUsers);const searchUsers = useCallback(async (keyword: string): Promise<ValueOption[]> => {- const { users } = await userStore.fetchUserList({+ const { users } = await listUsers({pageSize: getDefaultPagination(),filter: keyword.trim() ? { query: keyword } : undefined,});@@ -676,7 +676,7 @@ export function AuditLogTable({keywords: [u.email, u.title],}));},- [userStore]+ [listUsers]);const scopeOptions = useMemo((): ScopeOption[] => {diff --git a/frontend/src/react/components/CustomApproval/utils.ts b/frontend/src/react/components/CustomApproval/utils.tsindex 1a786ba4bb..618de4db35 100644--- a/frontend/src/react/components/CustomApproval/utils.ts+++ b/frontend/src/react/components/CustomApproval/utils.ts@@ -3,7 +3,8 @@ import { v4 as uuidv4 } from "uuid";import type { ConditionGroupExpr } from "@/plugins/cel";import { ExprType, type Factor, SQLTypeList, wrapAsGroup } from "@/plugins/cel";import i18n from "@/react/i18n";-import { useRoleStore } from "@/store";+import { displayRoleTitleFromList } from "@/react/lib/role";+import { useAppStore } from "@/react/stores/app";import type { LocalApprovalRule } from "@/types";import { PRESET_WORKSPACE_ROLES, PresetRoleType } from "@/types";import { Engine, RiskLevel } from "@/types/proto-es/v1/common_pb";@@ -11,7 +12,6 @@ import { ApprovalFlowSchema } from "@/types/proto-es/v1/issue_service_pb";import { WorkspaceApprovalSetting_Rule_Source } from "@/types/proto-es/v1/setting_service_pb";import type { ResourceSelectOption } from "@/types/v2-shared";import {- displayRoleTitle,engineNameV1,getEnvironmentIdOptions,getInstanceIdOptionConfig,@@ -212,10 +212,11 @@ const getSQLTypeOptions = (source: WorkspaceApprovalSetting_Rule_Source) => {};const getRoleOptions = () => {- return useRoleStore()- .roleList.filter((role) => !PRESET_WORKSPACE_ROLES.includes(role.name))+ const roleList = useAppStore.getState().roleList;+ return roleList+ .filter((role) => !PRESET_WORKSPACE_ROLES.includes(role.name)).map((role) => ({- label: displayRoleTitle(role.name),+ label: displayRoleTitleFromList(role.name, roleList),value: role.name,}));};diff --git a/frontend/src/react/components/IssueTable.tsx b/frontend/src/react/components/IssueTable.tsxindex 1af301449c..ae9f5f2d8f 100644--- a/frontend/src/react/components/IssueTable.tsx+++ b/frontend/src/react/components/IssueTable.tsx@@ -29,16 +29,13 @@ import { Tooltip } from "@/react/components/ui/tooltip";import { useClickOutside } from "@/react/hooks/useClickOutside";import { useEscapeKey } from "@/react/hooks/useEscapeKey";import { useVueState } from "@/react/hooks/useVueState";+import { displayRoleTitleFromList } from "@/react/lib/role";import { cn } from "@/react/lib/utils";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import { PROJECT_V1_ROUTE_DETAIL } from "@/router/dashboard/projectV1";import { WORKSPACE_ROUTE_USER_PROFILE } from "@/router/dashboard/workspaceRoutes";-import {- pushNotification,- useCurrentUserV1,- useProjectV1Store,- useUserStore,-} from "@/store";+import { pushNotification, useCurrentUserV1, useProjectV1Store } from "@/store";import {getTimeForPbTimestampProtoEs,isValidProjectName,@@ -53,7 +50,6 @@ import {} from "@/types/proto-es/v1/issue_service_pb";import type { Label } from "@/types/proto-es/v1/project_service_pb";import {- displayRoleTitle,extractIssueUID,extractProjectResourceName,getDefaultPagination,@@ -326,7 +322,7 @@ export function useIssueSearchScopeOptions(projectName?: string): ScopeOption[] {const { t } = useTranslation();- const userStore = useUserStore();+ const listUsers = useAppStore((state) => state.listUsers);const projectStore = useProjectV1Store();const currentUser = useCurrentUserV1();const me = useVueState(() => currentUser.value);@@ -346,7 +342,7 @@ export function useIssueSearchScopeOptions(const searchPrincipal = useCallback(async (keyword: string): Promise<ValueOption[]> => {- const resp = await userStore.fetchUserList({+ const resp = await listUsers({pageSize: getDefaultPagination(),filter: { query: keyword },});@@ -365,7 +361,7 @@ export function useIssueSearchScopeOptions(),}));},- [userStore, me, t]+ [listUsers, me, t]);return useMemo(@@ -573,10 +569,10 @@ export const IssueListItem = memo(function IssueListItem({showProject?: boolean;}) {const { t } = useTranslation();- const userStore = useUserStore();-- const creator =- userStore.getUserByIdentifier(issue.creator) || unknownUser(issue.creator);+ const creatorUser = useAppStore((state) =>+ state.getUserByIdentifier(issue.creator)+ );+ const creator = creatorUser || unknownUser(issue.creator);const issueProject = useMemo(() => projectOfIssue(issue), [issue]);@@ -831,6 +827,7 @@ function RiskLevelIcon({ riskLevel }: { riskLevel: RiskLevel }) {function IssueApprovalStatusTag({ issue }: { issue: Issue }) {const { t } = useTranslation();+ const roleList = useAppStore((state) => state.roleList);const approvalSteps = issue.approvalTemplate?.flow?.roles ?? [];if (issue.approvalStatus === ApprovalStatus.CHECKING) {@@ -875,7 +872,7 @@ function IssueApprovalStatusTag({ issue }: { issue: Issue }) {if (status === ApprovalStatus.PENDING) {const currentRoleIndex = issue.approvers.length;const role = approvalSteps[currentRoleIndex];- const roleName = role ? displayRoleTitle(role) : "";+ const roleName = role ? displayRoleTitleFromList(role, roleList) : "";return (<div className="shrink-0 flex flex-row sm:flex-col items-center sm:items-end gap-x-1.5 sm:gap-x-0 mt-1"><span className="inline-flex items-center rounded-full bg-control-bg px-2 py-0.5 text-xs text-control-light">diff --git a/frontend/src/react/components/RoleSelect.tsx b/frontend/src/react/components/RoleSelect.tsxindex efe2e5beab..52801bc29b 100644--- a/frontend/src/react/components/RoleSelect.tsx+++ b/frontend/src/react/components/RoleSelect.tsx@@ -3,7 +3,12 @@ import { useTranslation } from "react-i18next";import { FeatureBadge } from "@/react/components/FeatureBadge";import { Combobox, type ComboboxGroup } from "@/react/components/ui/combobox";import { useVueState } from "@/react/hooks/useVueState";-import { useRoleStore, useSubscriptionV1Store } from "@/store";+import {+ displayRoleDescriptionFromList,+ displayRoleTitleFromList,+} from "@/react/lib/role";+import { useAppStore } from "@/react/stores/app";+import { useSubscriptionV1Store } from "@/store";import {PRESET_PROJECT_ROLES,PRESET_ROLES,@@ -33,9 +38,8 @@ export function RoleSelect({filterRole,}: RoleSelectProps) {const { t } = useTranslation();- const roleStore = useRoleStore();const subscriptionStore = useSubscriptionV1Store();- const roleList = useVueState(() => [...roleStore.roleList]);+ const roleList = useAppStore((state) => state.roleList);const hasCustomRoleFeature = useVueState(() =>subscriptionStore.hasInstanceFeature(PlanFeature.FEATURE_CUSTOM_ROLES));@@ -46,7 +50,7 @@ export function RoleSelect({if (!filterRole) {return true;}- const role = roleStore.getRoleByName(name);+ const role = roleList.find((role) => role.name === name);return role ? filterRole(role) : false;};@@ -69,12 +73,12 @@ export function RoleSelect({.filter((r) => !filterRole || filterRole(r)).map((r) => ({value: r.name,- label: displayRoleTitle(r.name),- description: displayRoleDescription(r.name),+ label: displayRoleTitleFromList(r.name, roleList),+ description: displayRoleDescriptionFromList(r.name, roleList),disabled: !hasCustomRoleFeature,render: () => (<div className="flex items-center gap-x-1">- <span>{displayRoleTitle(r.name)}</span>+ <span>{displayRoleTitleFromList(r.name, roleList)}</span>{isCustomRole(r.name) && !hasCustomRoleFeature && (<FeatureBadgefeature={PlanFeature.FEATURE_CUSTOM_ROLES}@@ -96,7 +100,7 @@ export function RoleSelect({if (custom.length > 0)result.push({ label: t("role.custom-roles.self"), options: custom });return result;- }, [filterRole, roleList, roleStore, hasCustomRoleFeature, scope, t]);+ }, [filterRole, roleList, hasCustomRoleFeature, scope, t]);const defaultPlaceholder = multiple? t("settings.members.select-role", { count: 2 })diff --git a/frontend/src/react/components/UserSelect.tsx b/frontend/src/react/components/UserSelect.tsxindex 48848e01a8..7aaa925bdb 100644--- a/frontend/src/react/components/UserSelect.tsx+++ b/frontend/src/react/components/UserSelect.tsx@@ -1,6 +1,6 @@import { useCallback, useEffect, useMemo, useRef, useState } from "react";import { Combobox, type ComboboxOption } from "@/react/components/ui/combobox";-import { useUserStore } from "@/store";+import { useAppStore } from "@/react/stores/app";import { userNamePrefix } from "@/store/modules/v1/common";import { ALL_USERS_USER_EMAIL } from "@/types";import type { User } from "@/types/proto-es/v1/user_service_pb";@@ -34,7 +34,10 @@ export function UserSelect({className,includeAllUsers,}: UserSelectProps) {- const userStore = useUserStore();+ const listUsers = useAppStore((state) => state.listUsers);+ const getOrFetchUserByIdentifier = useAppStore(+ (state) => state.getOrFetchUserByIdentifier+ );const [users, setUsers] = useState<User[]>([]);const [selectedUser, setSelectedUser] = useState<User | undefined>(undefined);const [search, setSearch] = useState("");@@ -50,28 +53,26 @@ export function UserSelect({return;}let cancelled = false;- userStore.getOrFetchUserByIdentifier({ identifier: value }).then((user) => {+ getOrFetchUserByIdentifier({ identifier: value }).then((user) => {if (!cancelled) setSelectedUser(user);});return () => {cancelled = true;};- }, [value, userStore]);+ }, [value, getOrFetchUserByIdentifier]);const handleSearch = useCallback((query: string) => {setSearch(query);const seq = ++searchSeqRef.current;- userStore- .fetchUserList({- pageSize: getDefaultPagination(),- filter: { query: query.trim() },- })- .then(({ users: fetched }) => {- if (seq === searchSeqRef.current) setUsers(fetched);- });+ listUsers({+ pageSize: getDefaultPagination(),+ filter: { query: query.trim() },+ }).then(({ users: fetched }) => {+ if (seq === searchSeqRef.current) setUsers(fetched);+ });},- [userStore]+ [listUsers]);const options: ComboboxOption[] = useMemo(() => {diff --git a/frontend/src/react/components/revision/RevisionDetailPanel.tsx b/frontend/src/react/components/revision/RevisionDetailPanel.tsxindex b106db1a5c..d8037106fe 100644--- a/frontend/src/react/components/revision/RevisionDetailPanel.tsx+++ b/frontend/src/react/components/revision/RevisionDetailPanel.tsx@@ -4,9 +4,10 @@ import { useTranslation } from "react-i18next";import { sheetServiceClientConnect } from "@/connect";import { ReadonlyMonaco } from "@/react/components/monaco";import { TaskRunLogViewer } from "@/react/components/task-run-log";-import { useVueState } from "@/react/hooks/useVueState";+import { useRevisionByName } from "@/react/hooks/useAppState";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";-import { pushNotification, useRevisionStore } from "@/store";+import { pushNotification } from "@/store";import { getTimeForPbTimestampProtoEs } from "@/types";import { bytesToString, formatAbsoluteDateTime } from "@/utils";import { extractTaskLink, getRevisionType } from "@/utils/v1/revision";@@ -82,10 +83,8 @@ export function RevisionDetailPanel({revisionName,}: RevisionDetailPanelProps) {const { t } = useTranslation();- const revisionStore = useRevisionStore();- const revision = useVueState(() =>- revisionStore.getRevisionByName(revisionName)- );+ const fetchRevision = useAppStore((state) => state.fetchRevision);+ const revision = useRevisionByName(revisionName);const [loading, setLoading] = useState(false);const [statement, setStatement] = useState("");@@ -101,8 +100,7 @@ export function RevisionDetailPanel({setLoading(true);setStatement("");- void revisionStore- .getOrFetchRevisionByName(revisionName)+ void fetchRevision(revisionName).then(async (rev) => {if (!rev?.sheet) {return;@@ -132,7 +130,7 @@ export function RevisionDetailPanel({return () => {cancelled = true;};- }, [revisionName, revisionStore]);+ }, [fetchRevision, revisionName]);const taskFullLink = revision?.taskRun? extractTaskLink(revision.taskRun)diff --git a/frontend/src/react/components/sql-editor/RequestQueryButton.test.tsx b/frontend/src/react/components/sql-editor/RequestQueryButton.test.tsxindex f13ec9420b..0c46efd31c 100644--- a/frontend/src/react/components/sql-editor/RequestQueryButton.test.tsx+++ b/frontend/src/react/components/sql-editor/RequestQueryButton.test.tsx@@ -11,7 +11,7 @@ const mocks = vi.hoisted(() => ({useTranslation: vi.fn(() => ({ t: (key: string) => key })),useVueState: vi.fn<(getter: () => unknown) => unknown>(),useProjectV1Store: vi.fn(),- useRoleStore: vi.fn(),+ roleList: [] as Array<{ name: string; permissions: string[] }>,useSQLEditorVueState: vi.fn(),useSubscriptionV1Store: vi.fn(),hasFeature: vi.fn(() => true),@@ -31,11 +31,17 @@ vi.mock("@/react/hooks/useVueState", () => ({vi.mock("@/store", () => ({useProjectV1Store: mocks.useProjectV1Store,- useRoleStore: mocks.useRoleStore,useSubscriptionV1Store: mocks.useSubscriptionV1Store,hasFeature: mocks.hasFeature,}));+vi.mock("@/react/stores/app", () => ({+ useAppStore: (selector: (state: unknown) => unknown) =>+ selector({+ roleList: mocks.roleList,+ }),+}));+vi.mock("@/react/stores/sqlEditor/editor-vue-state", () => ({useSQLEditorVueState: mocks.useSQLEditorVueState,}));@@ -167,22 +173,20 @@ const setupDefaultMocks = (allowJIT = false, allowRequestRole = true) => {allowRequestRole,})),});- mocks.useRoleStore.mockReturnValue({- roleList: [- {- name: "roles/sqlEditorUser",- permissions: ["bb.sql.select", "bb.sql.dml", "bb.sql.explain"],- },- {- name: "roles/queryOnly",- permissions: ["bb.sql.select"],- },- {- name: "roles/sqlEditorReadUser",- permissions: ["bb.sql.select", "bb.sql.explain"],- },- ],- });+ mocks.roleList = [+ {+ name: "roles/sqlEditorUser",+ permissions: ["bb.sql.select", "bb.sql.dml", "bb.sql.explain"],+ },+ {+ name: "roles/queryOnly",+ permissions: ["bb.sql.select"],+ },+ {+ name: "roles/sqlEditorReadUser",+ permissions: ["bb.sql.select", "bb.sql.explain"],+ },+ ];mocks.useSQLEditorVueState.mockReturnValue({ project: "projects/proj1" });mocks.useSubscriptionV1Store.mockReturnValue({hasInstanceFeature: vi.fn(() => false),diff --git a/frontend/src/react/components/sql-editor/RequestQueryButton.tsx b/frontend/src/react/components/sql-editor/RequestQueryButton.tsxindex e2ddca77d6..f74cffbe9b 100644--- a/frontend/src/react/components/sql-editor/RequestQueryButton.tsx+++ b/frontend/src/react/components/sql-editor/RequestQueryButton.tsx@@ -7,13 +7,9 @@ import { Button } from "@/react/components/ui/button";import { useVueState } from "@/react/hooks/useVueState";import { cn } from "@/react/lib/utils";import { RequestRoleSheet } from "@/react/pages/settings/RequestRoleSheet";+import { useAppStore } from "@/react/stores/app";import { useSQLEditorVueState } from "@/react/stores/sqlEditor/editor-vue-state";-import {- hasFeature,- useProjectV1Store,- useRoleStore,- useSubscriptionV1Store,-} from "@/store";+import { hasFeature, useProjectV1Store, useSubscriptionV1Store } from "@/store";import type { DatabaseResource, Permission } from "@/types";import { PRESET_ROLES, PresetRoleType } from "@/types";import type { PermissionDeniedDetail } from "@/types/proto-es/v1/common_pb";@@ -70,6 +66,7 @@ export function RequestQueryButton({permissionDeniedDetail,}: Props) {const { t } = useTranslation();+ const roleList = useAppStore((state) => state.roleList);// When the layout-level host is mounted (typical case inside the SQL// Editor), opening the drawer dispatches up to the host so it survives@@ -82,7 +79,7 @@ export function RequestQueryButton({const projectStore = useProjectV1Store();const editorStore = useSQLEditorVueState();- const roleStore = useRoleStore();+const subscriptionStore = useSubscriptionV1Store();const projectName = useVueState(() => editorStore.project);@@ -92,7 +89,7 @@ export function RequestQueryButton({);const defaultQueryRole = useVueState(() =>getDefaultQueryRole(- roleStore.roleList,+ roleList,permissionDeniedDetail.requiredPermissions,hasCustomRoleFeature)diff --git a/frontend/src/react/components/sql-editor/TreeNodeSuffix.test.tsx b/frontend/src/react/components/sql-editor/TreeNodeSuffix.test.tsxindex d336a335b7..72fe61ffc3 100644--- a/frontend/src/react/components/sql-editor/TreeNodeSuffix.test.tsx+++ b/frontend/src/react/components/sql-editor/TreeNodeSuffix.test.tsx@@ -21,7 +21,10 @@ const mocks = vi.hoisted(() => ({useVueState: vi.fn<(getter: () => unknown) => unknown>(),useWorkSheetStore: vi.fn(),useSQLEditorTabStore: vi.fn(),- useUserStore: vi.fn(),+ getUserByIdentifier: vi.fn<() => { title: string } | undefined>(() => ({+ title: "Test User",+ })),+ getOrFetchUserByIdentifier: vi.fn(async () => ({ title: "Test User" })),useSheetContext: vi.fn(),}));@@ -35,7 +38,14 @@ vi.mock("@/react/hooks/useVueState", () => ({vi.mock("@/store", () => ({useWorkSheetStore: mocks.useWorkSheetStore,- useUserStore: mocks.useUserStore,+}));++vi.mock("@/react/stores/app", () => ({+ useAppStore: (selector: (state: unknown) => unknown) =>+ selector({+ getUserByIdentifier: mocks.getUserByIdentifier,+ getOrFetchUserByIdentifier: mocks.getOrFetchUserByIdentifier,+ }),}));vi.mock("@/react/stores/sqlEditor/tab-vue-state", () => ({@@ -132,9 +142,8 @@ beforeEach(async () => {mocks.useSQLEditorTabStore.mockReturnValue({closeTab: vi.fn(),});- mocks.useUserStore.mockReturnValue({- getUserByIdentifier: vi.fn(() => ({ title: "Test User" })),- });+ mocks.getUserByIdentifier.mockReturnValue({ title: "Test User" });+ mocks.getOrFetchUserByIdentifier.mockResolvedValue({ title: "Test User" });mocks.useSheetContext.mockReturnValue({isWorksheetCreator: vi.fn(() => true),});@@ -205,6 +214,31 @@ describe("TreeNodeSuffix", () => {unmount();});+ test("fetches worksheet creator before rendering the raw identifier", () => {+ mocks.getUserByIdentifier.mockReturnValue(undefined);+ const node = makeWorksheetNode();+ const onToggleStar = vi.fn();+ const onSharePanelShow = vi.fn();+ const onContextMenuShow = vi.fn();++ const { render, unmount } = renderIntoContainer(+ <TreeNodeSuffix+ node={node}+ view="my"+ onToggleStar={onToggleStar}+ onSharePanelShow={onSharePanelShow}+ onContextMenuShow={onContextMenuShow}+ />+ );+ render();++ expect(mocks.getOrFetchUserByIdentifier).toHaveBeenCalledWith({+ identifier: "users/[email protected]",+ });++ unmount();+ });+test('"More" button fires onContextMenuShow with the node', () => {const node = makeWorksheetNode();const onContextMenuShow = vi.fn();diff --git a/frontend/src/react/components/sql-editor/TreeNodeSuffix.tsx b/frontend/src/react/components/sql-editor/TreeNodeSuffix.tsxindex 0750fcdb16..3009b40132 100644--- a/frontend/src/react/components/sql-editor/TreeNodeSuffix.tsx+++ b/frontend/src/react/components/sql-editor/TreeNodeSuffix.tsx@@ -1,10 +1,12 @@import { MoreHorizontal, Star, Users, X } from "lucide-react";+import { useEffect } from "react";import { useTranslation } from "react-i18next";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 { useSQLEditorTabStore } from "@/react/stores/sqlEditor/tab-vue-state";-import { useUserStore, useWorkSheetStore } from "@/store";+import { useWorkSheetStore } from "@/store";import { Worksheet_Visibility } from "@/types/proto-es/v1/worksheet_service_pb";import type {SheetViewMode,@@ -40,7 +42,6 @@ export function TreeNodeSuffix({const worksheetStore = useWorkSheetStore();const tabStore = useSQLEditorTabStore();- const userStore = useUserStore();const { isWorksheetCreator } = useSheetContext();const worksheetLite = useVueState(() => {@@ -58,6 +59,25 @@ export function TreeNodeSuffix({creator: sheet.creator,};});+ const worksheetCreatorTitle = useAppStore((state) =>+ worksheetLite?.creator+ ? state.getUserByIdentifier(worksheetLite.creator)?.title+ : undefined+ );+ const getOrFetchUserByIdentifier = useAppStore(+ (state) => state.getOrFetchUserByIdentifier+ );++ useEffect(() => {+ if (!worksheetLite?.creator || worksheetCreatorTitle) {+ return;+ }+ void getOrFetchUserByIdentifier({ identifier: worksheetLite.creator });+ }, [+ getOrFetchUserByIdentifier,+ worksheetCreatorTitle,+ worksheetLite?.creator,+ ]);const visibilityDisplayName = (visibility: Worksheet_Visibility) => {switch (visibility) {@@ -73,7 +93,7 @@ export function TreeNodeSuffix({};const creatorForSheet = (creator: string) => {- return userStore.getUserByIdentifier(creator)?.title ?? creator;+ return worksheetCreatorTitle ?? creator;};// Draft view: show X button to close the draft tabdiff --git a/frontend/src/react/components/task-run-log/model.test.ts b/frontend/src/react/components/task-run-log/model.test.tsindex e5656a705c..4375cc731e 100644--- a/frontend/src/react/components/task-run-log/model.test.ts+++ b/frontend/src/react/components/task-run-log/model.test.ts@@ -35,8 +35,11 @@ vi.mock("@/react/hooks/useVueState", () => ({useVueState: () => undefined,}));+vi.mock("@/react/stores/app", () => ({+ useAppStore: () => vi.fn(),+}));+vi.mock("@/store", () => ({- useReleaseStore: () => ({}),useRolloutStore: () => ({}),}));diff --git a/frontend/src/react/components/task-run-log/useTaskRunLogData.ts b/frontend/src/react/components/task-run-log/useTaskRunLogData.tsindex 82be42ee80..aee171cb39 100644--- a/frontend/src/react/components/task-run-log/useTaskRunLogData.ts+++ b/frontend/src/react/components/task-run-log/useTaskRunLogData.ts@@ -5,7 +5,8 @@ import {sheetServiceClientConnect,} from "@/connect";import { useVueState } from "@/react/hooks/useVueState";-import { useReleaseStore, useRolloutStore } from "@/store";+import { useAppStore } from "@/react/stores/app";+import { useRolloutStore } from "@/store";import {GetTaskRunLogRequestSchema,type Task,@@ -156,7 +157,7 @@ export const useTaskRunLogData = (taskRunName?: string): UseTaskRunLogDataResult => {const rolloutStore = useRolloutStore();- const releaseStore = useReleaseStore();+ const fetchRelease = useAppStore((state) => state.fetchRelease);const [entries, setEntries] = useState<TaskRunLogEntry[]>([]);const [sheet, setSheet] = useState<Sheet | undefined>(undefined);@@ -285,11 +286,10 @@ export const useTaskRunLogData = (return;}- void releaseStore- .fetchReleaseByName(releaseName, true)+ void fetchRelease(releaseName, true).then(async (release) => {const fileSheets = await Promise.all(- release.files+ (release?.files ?? []).filter((file) => file.sheet && file.version).map(async (file) => {try {@@ -361,7 +361,7 @@ export const useTaskRunLogData = (});});}, [- releaseStore,+ fetchRelease,task,taskRunName,sheetFetchTaskKey,diff --git a/frontend/src/react/hooks/useAppState.ts b/frontend/src/react/hooks/useAppState.tsindex f99fbe7bf2..19e8234f2f 100644--- a/frontend/src/react/hooks/useAppState.ts+++ b/frontend/src/react/hooks/useAppState.ts@@ -278,6 +278,34 @@ export function useGroupByIdentifier(id: string) {return useAppStore((state) => state.getGroupByIdentifier(id));}+export function useUserByIdentifier(identifier: string | undefined) {+ return useAppStore((state) =>+ identifier ? state.getUserByIdentifier(identifier) : undefined+ );+}++export function useRoleByName(name: string | undefined) {+ return useAppStore((state) => (name ? state.getRoleByName(name) : undefined));+}++export function useReleaseByName(name: string | undefined) {+ return useAppStore((state) =>+ name ? state.getReleaseByName(name) : undefined+ );+}++export function useRevisionByName(name: string | undefined) {+ return useAppStore((state) =>+ name ? state.getRevisionByName(name) : undefined+ );+}++export function useChangelogByName(name: string | undefined) {+ return useAppStore((state) =>+ name ? state.getChangelogByName(name) : undefined+ );+}+export function useServiceAccount(name: string) {return useAppStore(useShallow((state) => state.getServiceAccount(name)));}diff --git a/frontend/src/react/lib/project-member/utils.test.ts b/frontend/src/react/lib/project-member/utils.test.tsindex 9774046a5d..701abf3dfd 100644--- a/frontend/src/react/lib/project-member/utils.test.ts+++ b/frontend/src/react/lib/project-member/utils.test.ts@@ -8,13 +8,24 @@ const fixtures: Record<string, string[]> = {"roles/queryOnly": ["bb.sql.select"],"roles/projectViewer": [],};-vi.mock("@/store", () => ({- useRoleStore: () => ({- getRoleByName: (role: string) =>- fixtures[role] === undefined- ? undefined- : { name: role, permissions: fixtures[role] },- }),+vi.mock("@/react/stores/app", () => ({+ useAppStore: Object.assign(+ (selector: (state: unknown) => unknown) =>+ selector({+ getRoleByName: (role: string) =>+ fixtures[role] === undefined+ ? undefined+ : { name: role, permissions: fixtures[role] },+ }),+ {+ getState: () => ({+ getRoleByName: (role: string) =>+ fixtures[role] === undefined+ ? undefined+ : { name: role, permissions: fixtures[role] },+ }),+ }+ ),}));vi.mock("@/utils", () => ({displayRoleTitle: (r: string) => r,diff --git a/frontend/src/react/lib/project-member/utils.ts b/frontend/src/react/lib/project-member/utils.tsindex c7d4f4c745..5cd3c7ff83 100644--- a/frontend/src/react/lib/project-member/utils.ts+++ b/frontend/src/react/lib/project-member/utils.ts@@ -1,9 +1,12 @@-import { useRoleStore } from "@/store";+import { displayRoleTitleFromList } from "@/react/lib/role";+import { useAppStore } from "@/react/stores/app";import type { Binding } from "@/types/proto-es/v1/iam_policy_pb";-import { checkRoleContainsAnyPermission, displayRoleTitle } from "@/utils";+import { checkRoleContainsAnyPermission } from "@/utils";export const getBindingIdentifier = (binding: Binding): string => {- const identifier = [displayRoleTitle(binding.role)];+ const identifier = [+ displayRoleTitleFromList(binding.role, useAppStore.getState().roleList),+ ];if (binding.condition && binding.condition.expression) {identifier.push(binding.condition.expression);}@@ -30,7 +33,7 @@ export type EnvLimitationKind = "DDL" | "DML" | "DDL/DML";export const getRoleEnvironmentLimitationKind = (role: string): EnvLimitationKind | undefined => {- const r = useRoleStore().getRoleByName(role);+ const r = useAppStore.getState().getRoleByName(role);if (!r) return undefined;const perms = new Set(r.permissions);const hasDDL = perms.has("bb.sql.ddl");diff --git a/frontend/src/react/lib/role.ts b/frontend/src/react/lib/role.tsnew file mode 100644index 0000000000..c530be43d9--- /dev/null+++ b/frontend/src/react/lib/role.ts@@ -0,0 +1,82 @@+import { t } from "@/plugins/i18n";+import type { Role } from "@/types/proto-es/v1/role_service_pb";++const PresetRoleType = {+ WORKSPACE_ADMIN: "roles/workspaceAdmin",+ WORKSPACE_DBA: "roles/workspaceDBA",+ WORKSPACE_MEMBER: "roles/workspaceMember",+ PROJECT_OWNER: "roles/projectOwner",+ PROJECT_DEVELOPER: "roles/projectDeveloper",+ SQL_EDITOR_USER: "roles/sqlEditorUser",+ SQL_EDITOR_READ_USER: "roles/sqlEditorReadUser",+ PROJECT_RELEASER: "roles/projectReleaser",+ GITOPS_SERVICE_AGENT: "roles/gitopsServiceAgent",+ PROJECT_VIEWER: "roles/projectViewer",+} as const;++const PRESET_ROLES: string[] = Object.values(PresetRoleType);++const PRESET_ROLE_TITLE_KEYS: Record<string, string> = {+ [PresetRoleType.WORKSPACE_ADMIN]: "role.workspace-admin.self",+ [PresetRoleType.WORKSPACE_DBA]: "role.workspace-dba.self",+ [PresetRoleType.WORKSPACE_MEMBER]: "role.workspace-member.self",+ [PresetRoleType.PROJECT_OWNER]: "role.project-owner.self",+ [PresetRoleType.PROJECT_DEVELOPER]: "role.project-developer.self",+ [PresetRoleType.PROJECT_RELEASER]: "role.project-releaser.self",+ [PresetRoleType.SQL_EDITOR_USER]: "role.sql-editor-user.self",+ [PresetRoleType.SQL_EDITOR_READ_USER]: "role.sql-editor-read-user.self",+ [PresetRoleType.GITOPS_SERVICE_AGENT]: "role.gitops-service-agent.self",+ [PresetRoleType.PROJECT_VIEWER]: "role.project-viewer.self",+};++const PRESET_ROLE_DESCRIPTION_KEYS: Record<string, string> = {+ [PresetRoleType.WORKSPACE_ADMIN]: "role.workspace-admin.description",+ [PresetRoleType.WORKSPACE_DBA]: "role.workspace-dba.description",+ [PresetRoleType.WORKSPACE_MEMBER]: "role.workspace-member.description",+ [PresetRoleType.PROJECT_OWNER]: "role.project-owner.description",+ [PresetRoleType.PROJECT_DEVELOPER]: "role.project-developer.description",+ [PresetRoleType.PROJECT_RELEASER]: "role.project-releaser.description",+ [PresetRoleType.SQL_EDITOR_USER]: "role.sql-editor-user.description",+ [PresetRoleType.SQL_EDITOR_READ_USER]:+ "role.sql-editor-read-user.description",+ [PresetRoleType.GITOPS_SERVICE_AGENT]:+ "role.gitops-service-agent.description",+ [PresetRoleType.PROJECT_VIEWER]: "role.project-viewer.description",+};++const extractRoleResourceName = (resourceId: string): string => {+ const pattern = /(?:^|\/)roles\/([^/]+)(?:$|\/)/;+ const matches = resourceId.match(pattern);+ return matches?.[1] ?? "";+};++const displayPresetRoleTitle = (roleName: string): string => {+ const key = PRESET_ROLE_TITLE_KEYS[roleName];+ return key ? t(key) : roleName;+};++const displayPresetRoleDescription = (roleName: string): string => {+ const key = PRESET_ROLE_DESCRIPTION_KEYS[roleName];+ return key ? t(key) : roleName;+};++export const displayRoleTitleFromList = (+ roleName: string,+ roleList: Role[]+) => {+ if (PRESET_ROLES.includes(roleName)) {+ return displayPresetRoleTitle(roleName);+ }+ const role = roleList.find((role) => role.name === roleName);+ return role?.title || extractRoleResourceName(roleName) || roleName;+};++export const displayRoleDescriptionFromList = (+ roleName: string,+ roleList: Role[]+) => {+ if (PRESET_ROLES.includes(roleName)) {+ return displayPresetRoleDescription(roleName);+ }+ return roleList.find((role) => role.name === roleName)?.description;+};diff --git a/frontend/src/react/no-legacy-vue-deps.test.ts b/frontend/src/react/no-legacy-vue-deps.test.tsindex b16e0b3df9..75dc8c9bea 100644--- a/frontend/src/react/no-legacy-vue-deps.test.ts+++ b/frontend/src/react/no-legacy-vue-deps.test.ts@@ -138,4 +138,30 @@ describe("React Project and Settings legacy Vue dependencies", () => {}expect(violations).toEqual([]);});++ test("Phase 2 protobuf resource consumers use the React app store", () => {+ const bannedImports = [+ "useUserStore",+ "useRoleStore",+ "useReleaseStore",+ "useRevisionStore",+ "useChangelogStore",+ "useProjectWebhookV1Store",+ "@/store/modules/user",+ "@/store/modules/role",+ "@/store/modules/release",+ "@/store/modules/revision",+ "@/store/modules/v1/changelog",+ "@/store/modules/v1/projectWebhook",+ ];+ 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/PasswordResetPage.test.tsx b/frontend/src/react/pages/auth/PasswordResetPage.test.tsxindex cd3daee940..d428864129 100644--- a/frontend/src/react/pages/auth/PasswordResetPage.test.tsx+++ b/frontend/src/react/pages/auth/PasswordResetPage.test.tsx@@ -23,7 +23,7 @@ const mocks = vi.hoisted(() => ({login: vi.fn(async () => {}),})),useCurrentUserV1: vi.fn(() => ({ value: { name: "users/1", email: "u@e" } })),- useUserStore: vi.fn(() => ({ updateUser: vi.fn() })),+ updateUser: vi.fn(),pushNotification: vi.fn(),routerReplace: vi.fn(),routerPush: vi.fn(),@@ -43,10 +43,23 @@ vi.mock("@/store", () => ({useActuatorV1Store: mocks.useActuatorV1Store,useAuthStore: mocks.useAuthStore,useCurrentUserV1: mocks.useCurrentUserV1,- useUserStore: mocks.useUserStore,pushNotification: mocks.pushNotification,}));+vi.mock("@/react/stores/app", () => ({+ useAppStore: Object.assign(+ (selector: (state: unknown) => unknown) =>+ selector({+ updateUser: mocks.updateUser,+ }),+ {+ getState: () => ({+ updateUser: mocks.updateUser,+ }),+ }+ ),+}));+vi.mock("@/router", () => ({router: {replace: mocks.routerReplace,diff --git a/frontend/src/react/pages/auth/PasswordResetPage.tsx b/frontend/src/react/pages/auth/PasswordResetPage.tsxindex 8629049ad4..16b41afb83 100644--- a/frontend/src/react/pages/auth/PasswordResetPage.tsx+++ b/frontend/src/react/pages/auth/PasswordResetPage.tsx@@ -10,6 +10,7 @@ import { Button } from "@/react/components/ui/button";import { Input } from "@/react/components/ui/input";import { OtpInput } from "@/react/components/ui/otp-input";import { useVueState } from "@/react/hooks/useVueState";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import { AUTH_SIGNIN_MODULE } from "@/router/auth";import {@@ -17,7 +18,6 @@ import {useActuatorV1Store,useAuthStore,useCurrentUserV1,- useUserStore,} from "@/store";import {LoginRequestSchema,@@ -157,7 +157,7 @@ export function PasswordResetPage() {// Forced-reset modeif (!currentUser) return;const patch = { ...currentUser, password };- await useUserStore().updateUser(+ await useAppStore.getState().updateUser(create(UpdateUserRequestSchema, {user: patch,updateMask: create(FieldMaskSchema, { paths: ["password"] }),diff --git a/frontend/src/react/pages/auth/ProfileSetupPage.tsx b/frontend/src/react/pages/auth/ProfileSetupPage.tsxindex 8305367ec6..6fb548b3fb 100644--- a/frontend/src/react/pages/auth/ProfileSetupPage.tsx+++ b/frontend/src/react/pages/auth/ProfileSetupPage.tsx@@ -6,11 +6,11 @@ import { UserAvatar } from "@/react/components/UserAvatar";import { Button } from "@/react/components/ui/button";import { Input } from "@/react/components/ui/input";import { useVueState } from "@/react/hooks/useVueState";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import {pushNotification,useCurrentUserV1,- useUserStore,useWorkspaceV1Store,} from "@/store";import { UpdateUserRequestSchema } from "@/types/proto-es/v1/user_service_pb";@@ -20,7 +20,7 @@ import { hasWorkspacePermissionV2 } from "@/utils";export function ProfileSetupPage() {const { t } = useTranslation();const currentUser = useVueState(() => useCurrentUserV1().value);- const userStore = useUserStore();+ const updateUser = useAppStore((state) => state.updateUser);const workspaceStore = useWorkspaceV1Store();const workspace = useVueState(() => workspaceStore.currentWorkspace);const workspacePolicy = useVueState(() => workspaceStore.workspaceIamPolicy);@@ -47,7 +47,7 @@ export function ProfileSetupPage() {if (!currentUser?.name || !name.trim()) return;setSaving(true);try {- await userStore.updateUser(+ await updateUser(create(UpdateUserRequestSchema, {user: { name: currentUser.name, title: name.trim() },updateMask: create(FieldMaskSchema, { paths: ["title"] }),diff --git a/frontend/src/react/pages/auth/SetupPage.test.tsx b/frontend/src/react/pages/auth/SetupPage.test.tsxindex c314c56a35..c5364f2202 100644--- a/frontend/src/react/pages/auth/SetupPage.test.tsx+++ b/frontend/src/react/pages/auth/SetupPage.test.tsx@@ -11,7 +11,7 @@ import { beforeEach, describe, expect, test, vi } from "vitest";const mocks = vi.hoisted(() => ({routerIsReady: vi.fn(async () => {}),routerPush: vi.fn(),- fetchRoleList: vi.fn(async () => {}),+ listRoles: vi.fn(async () => {}),fetchIamPolicy: vi.fn(async () => {}),getOrFetchProjectByName: vi.fn(async () => {throw new ConnectError("not found", Code.NotFound);@@ -43,9 +43,6 @@ vi.mock("@/store", () => ({getOrFetchProjectByName: mocks.getOrFetchProjectByName,createProject: mocks.createProject,}),- useRoleStore: () => ({- fetchRoleList: mocks.fetchRoleList,- }),useSettingV1Store: () => ({updateWorkspaceProfile: mocks.updateWorkspaceProfile,}),@@ -54,6 +51,20 @@ vi.mock("@/store", () => ({}),}));+vi.mock("@/react/stores/app", () => ({+ useAppStore: Object.assign(+ (selector: (state: unknown) => unknown) =>+ selector({+ listRoles: mocks.listRoles,+ }),+ {+ getState: () => ({+ listRoles: mocks.listRoles,+ }),+ }+ ),+}));+vi.mock("@/react/hooks/useVueState", () => ({useVueState: mocks.useVueState,}));diff --git a/frontend/src/react/pages/auth/SetupPage.tsx b/frontend/src/react/pages/auth/SetupPage.tsxindex 6ec75c17c5..9814f7e95e 100644--- a/frontend/src/react/pages/auth/SetupPage.tsx+++ b/frontend/src/react/pages/auth/SetupPage.tsx@@ -14,13 +14,13 @@ import { Button } from "@/react/components/ui/button";import { Input } from "@/react/components/ui/input";import { RadioGroup, RadioGroupItem } from "@/react/components/ui/radio-group";import { useVueState } from "@/react/hooks/useVueState";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import { SQL_EDITOR_HOME_MODULE } from "@/router/sqlEditor";import {useActuatorV1Store,useAppFeature,useProjectV1Store,- useRoleStore,useSettingV1Store,useWorkspaceV1Store,} from "@/store";@@ -56,7 +56,7 @@ export function SetupPage() {await router.isReady();try {await Promise.all([- useRoleStore().fetchRoleList(),+ useAppStore.getState().listRoles(),useWorkspaceV1Store().fetchIamPolicy(),]);} catch (error) {diff --git a/frontend/src/react/pages/project/DatabaseChangelogDetailPage.test.tsx b/frontend/src/react/pages/project/DatabaseChangelogDetailPage.test.tsxindex 896c2ed3fa..3731836342 100644--- a/frontend/src/react/pages/project/DatabaseChangelogDetailPage.test.tsx+++ b/frontend/src/react/pages/project/DatabaseChangelogDetailPage.test.tsx@@ -40,7 +40,7 @@ const mocks = vi.hoisted(() => {getOrFetchChangelogByName: vi.fn(),fetchPreviousChangelog: vi.fn(),getChangelogByName: vi.fn(),- useChangelogStore: vi.fn(),+ useAppStore: vi.fn(),getTaskRunLog: vi.fn(),useVueState: vi.fn((getter: () => unknown) => getter()),clipboardWriteText,@@ -165,9 +165,12 @@ vi.mock("@/react/hooks/useVueState", () => ({useVueState: mocks.useVueState,}));+vi.mock("@/react/stores/app", () => ({+ useAppStore: mocks.useAppStore,+}));+vi.mock("@/store", () => ({pushNotification: mocks.pushNotification,- useChangelogStore: mocks.useChangelogStore,}));vi.mock("@/connect", () => ({@@ -244,7 +247,7 @@ beforeEach(() => {mocks.getOrFetchChangelogByName.mockReset();mocks.fetchPreviousChangelog.mockReset();mocks.getChangelogByName.mockReset();- mocks.useChangelogStore.mockReset();+ mocks.useAppStore.mockReset();mocks.getTaskRunLog.mockReset();mocks.pushNotification.mockReset();mocks.useVueState.mockImplementation((getter: () => unknown) => getter());@@ -293,11 +296,13 @@ beforeEach(() => {}return undefined;});- mocks.useChangelogStore.mockReturnValue({- getOrFetchChangelogByName: mocks.getOrFetchChangelogByName,- fetchPreviousChangelog: mocks.fetchPreviousChangelog,- getChangelogByName: mocks.getChangelogByName,- });+ mocks.useAppStore.mockImplementation((selector) =>+ selector({+ getOrFetchChangelogByName: mocks.getOrFetchChangelogByName,+ fetchPreviousChangelog: mocks.fetchPreviousChangelog,+ getChangelogByName: mocks.getChangelogByName,+ })+ );mocks.getTaskRunLog.mockResolvedValue({entries: [{diff --git a/frontend/src/react/pages/project/DatabaseChangelogDetailPage.tsx b/frontend/src/react/pages/project/DatabaseChangelogDetailPage.tsxindex 4c95fb72dd..7983932699 100644--- a/frontend/src/react/pages/project/DatabaseChangelogDetailPage.tsx+++ b/frontend/src/react/pages/project/DatabaseChangelogDetailPage.tsx@@ -7,7 +7,7 @@ import { ReadonlyDiffMonaco, ReadonlyMonaco } from "@/react/components/monaco";import { TaskRunLogViewer } from "@/react/components/task-run-log";import { Button } from "@/react/components/ui/button";import { Switch } from "@/react/components/ui/switch";-import { useVueState } from "@/react/hooks/useVueState";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import {PROJECT_V1_ROUTE_DATABASE_CHANGELOG_DETAIL,@@ -15,7 +15,7 @@ import {PROJECT_V1_ROUTE_DATABASES,PROJECT_V1_ROUTE_SYNC_SCHEMA,} from "@/router/dashboard/projectV1";-import { pushNotification, useChangelogStore } from "@/store";+import { pushNotification } from "@/store";import { getTimeForPbTimestampProtoEs } from "@/types";import type { Changelog } from "@/types/proto-es/v1/database_service_pb";import {@@ -200,7 +200,12 @@ export function DatabaseChangelogDetailPage({changelogId,}: DatabaseChangelogDetailPageProps) {const { t } = useTranslation();- const changelogStore = useChangelogStore();+ const getOrFetchChangelogByName = useAppStore(+ (state) => state.getOrFetchChangelogByName+ );+ const fetchPreviousChangelog = useAppStore(+ (state) => state.fetchPreviousChangelog+ );const [loading, setLoading] = useState(true);const [showDiff, setShowDiff] = useState(true);const [resolvedChangelog, setResolvedChangelog] = useState<Changelog>();@@ -222,8 +227,8 @@ export function DatabaseChangelogDetailPage({});const changelogName = `${detail.databaseName}/changelogs/${changelogId}`;- const changelog = useVueState(() =>- changelogStore.getChangelogByName(changelogName, ChangelogView.FULL)+ const changelog = useAppStore((state) =>+ state.getChangelogByName(changelogName, ChangelogView.FULL));useEffect(() => {@@ -247,11 +252,8 @@ export function DatabaseChangelogDetailPage({setHasTaskRunDatabaseSync(undefined);void Promise.all([- changelogStore.getOrFetchChangelogByName(- changelogName,- ChangelogView.FULL- ),- changelogStore.fetchPreviousChangelog(changelogName),+ getOrFetchChangelogByName(changelogName, ChangelogView.FULL),+ fetchPreviousChangelog(changelogName),]).then(([current, previous]) => {if (cancelled) {@@ -278,7 +280,12 @@ export function DatabaseChangelogDetailPage({return () => {cancelled = true;};- }, [changelogName, changelogStore, detail.ready]);+ }, [+ changelogName,+ detail.ready,+ fetchPreviousChangelog,+ getOrFetchChangelogByName,+ ]);useEffect(() => {let cancelled = false;diff --git a/frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx b/frontend/src/react/pages/project/ProjectAccessGrantsPage.tsxindex 5dd5b2972b..91b729acd1 100644--- a/frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx+++ b/frontend/src/react/pages/project/ProjectAccessGrantsPage.tsx@@ -41,7 +41,6 @@ import {useCurrentUserV1,useDatabaseV1Store,useProjectV1Store,- useUserStore,} from "@/store";import { extractUserEmail, projectNamePrefix } from "@/store/modules/v1/common";import { getTimeForPbTimestampProtoEs } from "@/types";@@ -114,7 +113,7 @@ export function ProjectAccessGrantsPage({ projectId }: { projectId: string }) {const { t } = useTranslation();const projectStore = useProjectV1Store();const databaseStore = useDatabaseV1Store();- const userStore = useUserStore();+ const listUsers = useAppStore((state) => state.listUsers);const listAccessGrants = useAppStore((state) => state.listAccessGrants);const activateAccessGrant = useAppStore((state) => state.activateAccessGrant);const revokeAccessGrant = useAppStore((state) => state.revokeAccessGrant);@@ -202,7 +201,7 @@ export function ProjectAccessGrantsPage({ projectId }: { projectId: string }) {// Server-side search for creator filter optionsconst searchUsers = useCallback(async (keyword: string): Promise<ValueOption[]> => {- const result = await userStore.fetchUserList({+ const result = await listUsers({pageSize: getDefaultPagination(),filter: keyword ? { query: keyword } : undefined,});@@ -231,7 +230,7 @@ export function ProjectAccessGrantsPage({ projectId }: { projectId: string }) {),}));},- [userStore, currentUser, t]+ [listUsers, currentUser, t]);const scopeOptions: ScopeOption[] = useMemo(diff --git a/frontend/src/react/pages/project/ProjectDataExportPage.creators.test.ts b/frontend/src/react/pages/project/ProjectDataExportPage.creators.test.tsnew file mode 100644index 0000000000..ffb94111d0--- /dev/null+++ b/frontend/src/react/pages/project/ProjectDataExportPage.creators.test.ts@@ -0,0 +1,14 @@+import { describe, expect, test } from "vitest";++import source from "./ProjectDataExportPage.tsx?raw";++describe("data export issue list creator cache", () => {+ test("fetches listed issue creators before rendering fallback names", () => {+ expect(source).toMatch(+ /const batchGetOrFetchUsers = useAppStore\(\s*\(state\) => state\.batchGetOrFetchUsers\s*\)/+ );+ expect(source).toMatch(+ /batchGetOrFetchUsers\(paged\.dataList\.map\(\(issue\) => issue\.creator\)\)/+ );+ });+});diff --git a/frontend/src/react/pages/project/ProjectDataExportPage.tsx b/frontend/src/react/pages/project/ProjectDataExportPage.tsxindex f043200b00..49ea89fdcc 100644--- a/frontend/src/react/pages/project/ProjectDataExportPage.tsx+++ b/frontend/src/react/pages/project/ProjectDataExportPage.tsx@@ -13,6 +13,8 @@ import { Button } from "@/react/components/ui/button";import { Tooltip } from "@/react/components/ui/tooltip";import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";import { useVueState } from "@/react/hooks/useVueState";+import { displayRoleTitleFromList } from "@/react/lib/role";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import { WORKSPACE_ROUTE_USER_PROFILE } from "@/router/dashboard/workspaceRoutes";import {@@ -20,7 +22,6 @@ import {useInstanceV1Store,useIssueV1Store,useProjectV1Store,- useUserStore,} from "@/store";import { projectNamePrefix } from "@/store/modules/v1/common";import { getTimeForPbTimestampProtoEs, unknownUser } from "@/types";@@ -29,7 +30,6 @@ import type { Issue } from "@/types/proto-es/v1/issue_service_pb";import { Issue_Type, IssueStatus } from "@/types/proto-es/v1/issue_service_pb";import {buildIssueFilterBySearchParams,- displayRoleTitle,extractDatabaseResourceName,extractInstanceResourceName,extractIssueUID,@@ -49,6 +49,9 @@ export function ProjectDataExportPage({ projectId }: { projectId: string }) {const { t } = useTranslation();const issueStore = useIssueV1Store();const projectStore = useProjectV1Store();+ const batchGetOrFetchUsers = useAppStore(+ (state) => state.batchGetOrFetchUsers+ );const projectName = `${projectNamePrefix}${projectId}`;const project = useVueState(() => projectStore.getProjectByName(projectName));@@ -205,6 +208,13 @@ export function ProjectDataExportPage({ projectId }: { projectId: string }) {fetchList: fetchIssueList,});+ useEffect(() => {+ if (paged.dataList.length === 0) {+ return;+ }+ void batchGetOrFetchUsers(paged.dataList.map((issue) => issue.creator));+ }, [batchGetOrFetchUsers, paged.dataList]);+return (<div className="py-4 w-full flex flex-col"><div className="px-4">@@ -364,6 +374,7 @@ function RiskLevelIcon({ riskLevel }: { riskLevel: RiskLevel }) {function IssueApprovalStatusTag({ issue }: { issue: Issue }) {const { t } = useTranslation();+ const roleList = useAppStore((state) => state.roleList);const approvalSteps = issue.approvalTemplate?.flow?.roles ?? [];if (issue.approvalStatus === ApprovalStatus.CHECKING) {@@ -408,7 +419,7 @@ function IssueApprovalStatusTag({ issue }: { issue: Issue }) {if (status === ApprovalStatus.PENDING) {const currentRoleIndex = issue.approvers.length;const role = approvalSteps[currentRoleIndex];- const roleName = role ? displayRoleTitle(role) : "";+ const roleName = role ? displayRoleTitleFromList(role, roleList) : "";return (<div className="shrink-0 flex flex-row sm:flex-col items-center sm:items-end gap-x-1.5 sm:gap-x-0 mt-1"><span className="inline-flex items-center rounded-full bg-control-bg px-2 py-0.5 text-xs text-control-light">@@ -444,11 +455,12 @@ function IssueListItem({highlightText?: string;}) {const { t } = useTranslation();- const userStore = useUserStore();const projectStore = useProjectV1Store();- const creator =- userStore.getUserByIdentifier(issue.creator) || unknownUser(issue.creator);+ const creatorUser = useAppStore((state) =>+ state.getUserByIdentifier(issue.creator)+ );+ const creator = creatorUser || unknownUser(issue.creator);const issueProject = useVueState(() =>projectStore.getProjectByName(diff --git a/frontend/src/react/pages/project/ProjectIssueDashboardPage.creators.test.ts b/frontend/src/react/pages/project/ProjectIssueDashboardPage.creators.test.tsnew file mode 100644index 0000000000..74cd7d992a--- /dev/null+++ b/frontend/src/react/pages/project/ProjectIssueDashboardPage.creators.test.ts@@ -0,0 +1,14 @@+import { describe, expect, test } from "vitest";++import source from "./ProjectIssueDashboardPage.tsx?raw";++describe("project issue list creator cache", () => {+ test("fetches listed issue creators before rendering fallback names", () => {+ expect(source).toMatch(+ /const batchGetOrFetchUsers = useAppStore\(\s*\(state\) => state\.batchGetOrFetchUsers\s*\)/+ );+ expect(source).toMatch(+ /batchGetOrFetchUsers\(paged\.dataList\.map\(\(issue\) => issue\.creator\)\)/+ );+ });+});diff --git a/frontend/src/react/pages/project/ProjectIssueDashboardPage.tsx b/frontend/src/react/pages/project/ProjectIssueDashboardPage.tsxindex 24561a20e0..721070bcce 100644--- a/frontend/src/react/pages/project/ProjectIssueDashboardPage.tsx+++ b/frontend/src/react/pages/project/ProjectIssueDashboardPage.tsx@@ -13,6 +13,7 @@ import {import { Alert } from "@/react/components/ui/alert";import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";import { useVueState } from "@/react/hooks/useVueState";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import {refreshIssueList,@@ -42,6 +43,9 @@ export function ProjectIssueDashboardPage({const issueStore = useIssueV1Store();const uiStateStore = useUIStateStore();const currentUser = useCurrentUserV1();+ const batchGetOrFetchUsers = useAppStore(+ (state) => state.batchGetOrFetchUsers+ );const me = useVueState(() => currentUser.value);const projectName = `${projectNamePrefix}${projectId}`;@@ -175,6 +179,13 @@ export function ProjectIssueDashboardPage({fetchList: fetchIssueList,});+ useEffect(() => {+ if (paged.dataList.length === 0) {+ return;+ }+ void batchGetOrFetchUsers(paged.dataList.map((issue) => issue.creator));+ }, [batchGetOrFetchUsers, paged.dataList]);+// Scope optionsconst scopeOptions = useIssueSearchScopeOptions(projectName);diff --git a/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsx b/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsxindex 4e4fb89784..1f4df301f1 100644--- a/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsx+++ b/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsx@@ -56,7 +56,6 @@ import {usePolicyV1Store,useProjectV1Store,useSettingV1Store,- useUserStore,} from "@/store";import { projectNamePrefix } from "@/store/modules/v1/common";import type { DatabaseResource } from "@/types";@@ -99,7 +98,7 @@ export function ProjectMaskingExemptionPage({const { t } = useTranslation();const projectStore = useProjectV1Store();const databaseStore = useDatabaseV1Store();- const userStore = useUserStore();+ const listUsers = useAppStore((state) => state.listUsers);const currentUser = useVueState(() => useCurrentUserV1().value);const projectName = `${projectNamePrefix}${projectId}`;@@ -303,7 +302,7 @@ export function ProjectMaskingExemptionPage({const searchUsers = useCallback(async (keyword: string): Promise<ValueOption[]> => {- const result = await userStore.fetchUserList({+ const result = await listUsers({pageSize: getDefaultPagination(),filter: keyword ? { query: keyword } : undefined,});@@ -332,7 +331,7 @@ export function ProjectMaskingExemptionPage({),}));},- [userStore, currentUser, t]+ [listUsers, currentUser, t]);const scopeOptions: ScopeOption[] = useMemo(diff --git a/frontend/src/react/pages/project/ProjectPlanDashboardPage.columns.test.ts b/frontend/src/react/pages/project/ProjectPlanDashboardPage.columns.test.tsindex 89f9988f56..ca4988774f 100644--- a/frontend/src/react/pages/project/ProjectPlanDashboardPage.columns.test.ts+++ b/frontend/src/react/pages/project/ProjectPlanDashboardPage.columns.test.ts@@ -74,4 +74,13 @@ describe("plan list column composition", () => {expect(source).not.toContain("checkSummary");expect(source).not.toContain("hasAnyCheck");});++ test("plan row creators are fetched before rendering fallback names", () => {+ expect(source).toMatch(+ /const batchGetOrFetchUsers = useAppStore\(\s*\(state\) => state\.batchGetOrFetchUsers\s*\)/+ );+ expect(source).toMatch(+ /batchGetOrFetchUsers\(paged\.dataList\.map\(\(plan\) => plan\.creator\)\)/+ );+ });});diff --git a/frontend/src/react/pages/project/ProjectPlanDashboardPage.tsx b/frontend/src/react/pages/project/ProjectPlanDashboardPage.tsxindex b83f119b60..2fd6045f56 100644--- a/frontend/src/react/pages/project/ProjectPlanDashboardPage.tsx+++ b/frontend/src/react/pages/project/ProjectPlanDashboardPage.tsx@@ -51,6 +51,7 @@ import { useSessionPageSize } from "@/react/hooks/useSessionPageSize";import { useVueState } from "@/react/hooks/useVueState";import { applyPlanTitleToQuery } from "@/react/lib/plan/title";import { cn } from "@/react/lib/utils";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import {PROJECT_V1_ROUTE_PLAN_DETAIL,@@ -64,7 +65,6 @@ import {useEnvironmentV1Store,useProjectV1Store,useUIStateStore,- useUserStore,} from "@/store";import { projectNamePrefix } from "@/store/modules/v1/common";import {@@ -124,7 +124,10 @@ export function ProjectPlanDashboardPage({ projectId }: { projectId: string }) {const { t } = useTranslation();const planStore = usePlanStore();const projectStore = useProjectV1Store();- const userStore = useUserStore();+ const listUsers = useAppStore((state) => state.listUsers);+ const batchGetOrFetchUsers = useAppStore(+ (state) => state.batchGetOrFetchUsers+ );const uiStateStore = useUIStateStore();const currentUser = useCurrentUserV1();@@ -187,7 +190,7 @@ export function ProjectPlanDashboardPage({ projectId }: { projectId: string }) {title: t("issue.advanced-search.scope.creator.title"),description: t("issue.advanced-search.scope.creator.description"),onSearch: async (keyword: string) => {- const resp = await userStore.fetchUserList({+ const resp = await listUsers({pageSize: getDefaultPagination(),filter: { query: keyword },});@@ -208,7 +211,7 @@ export function ProjectPlanDashboardPage({ projectId }: { projectId: string }) {},},],- [t, userStore, me]+ [t, listUsers, me]);const [canCreate] = usePermissionCheck(["bb.plans.create"], project);@@ -244,6 +247,13 @@ export function ProjectPlanDashboardPage({ projectId }: { projectId: string }) {fetchList: fetchPlanList,});+ useEffect(() => {+ if (paged.dataList.length === 0) {+ return;+ }+ void batchGetOrFetchUsers(paged.dataList.map((plan) => plan.creator));+ }, [batchGetOrFetchUsers, paged.dataList]);+// Handle spec created from AddSpecDrawerconst handleSpecCreated = useCallback(async (spec: Plan_Spec) => {@@ -570,15 +580,16 @@ function PlanRow({projectId: string;columns: PlanColumn[];}>) {- const userStore = useUserStore();const environmentStore = useEnvironmentV1Store();const { t } = useTranslation();const isDeleted = plan.state === State.DELETED;const showDraftTag = plan.issue === "" && !plan.hasRollout;- const creator =- userStore.getUserByIdentifier(plan.creator) || unknownUser(plan.creator);+ const creatorUser = useAppStore((state) =>+ state.getUserByIdentifier(plan.creator)+ );+ const creator = creatorUser || unknownUser(plan.creator);const updateTimeTs = Math.floor(getTimeForPbTimestampProtoEs(plan.updateTime, 0) / 1000diff --git a/frontend/src/react/pages/project/ProjectReleaseDashboardPage.tsx b/frontend/src/react/pages/project/ProjectReleaseDashboardPage.tsxindex 7e16054eed..dfeaa02043 100644--- a/frontend/src/react/pages/project/ProjectReleaseDashboardPage.tsx+++ b/frontend/src/react/pages/project/ProjectReleaseDashboardPage.tsx@@ -17,8 +17,8 @@ import {} from "@/react/components/ui/table";import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";import { cn } from "@/react/lib/utils";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";-import { useReleaseStore } from "@/store";import { projectNamePrefix } from "@/store/modules/v1/common";import { getTimeForPbTimestampProtoEs } from "@/types";import { State } from "@/types/proto-es/v1/common_pb";@@ -34,7 +34,9 @@ export function ProjectReleaseDashboardPage({projectId: string;}) {const { t } = useTranslation();- const releaseStore = useReleaseStore();+ const listReleasesByProject = useAppStore(+ (state) => state.listReleasesByProject+ );const projectName = `${projectNamePrefix}${projectId}`;// Category filter from URL@@ -76,16 +78,15 @@ export function ProjectReleaseDashboardPage({const fetchReleaseList = useCallback(async (params: { pageSize: number; pageToken: string }) => {const filter = buildCategoryFilter(selectedCategory);- const { nextPageToken, releases } =- await releaseStore.fetchReleasesByProject(- projectName,- { pageSize: params.pageSize, pageToken: params.pageToken },- false,- filter- );+ const { nextPageToken, releases } = await listReleasesByProject(+ projectName,+ { pageSize: params.pageSize, pageToken: params.pageToken },+ false,+ filter+ );return { list: releases, nextPageToken };},- [releaseStore, projectName, selectedCategory]+ [listReleasesByProject, projectName, selectedCategory]);const paged = usePagedData<Release>({diff --git a/frontend/src/react/pages/project/ProjectReleaseDetailPage.tsx b/frontend/src/react/pages/project/ProjectReleaseDetailPage.tsxindex 8b2aead07a..08e278ab48 100644--- a/frontend/src/react/pages/project/ProjectReleaseDetailPage.tsx+++ b/frontend/src/react/pages/project/ProjectReleaseDetailPage.tsx@@ -26,7 +26,8 @@ import {SheetTitle,} from "@/react/components/ui/sheet";import { useVueState } from "@/react/hooks/useVueState";-import { pushNotification, useProjectV1Store, useReleaseStore } from "@/store";+import { useAppStore } from "@/react/stores/app";+import { pushNotification, useProjectV1Store } from "@/store";import { projectNamePrefix } from "@/store/modules/v1/common";import { getTimeForPbTimestampProtoEs } from "@/types";import { State, VCSType } from "@/types/proto-es/v1/common_pb";@@ -41,13 +42,15 @@ export function ProjectReleaseDetailPage({releaseId: string;}) {const { t } = useTranslation();- const releaseStore = useReleaseStore();+ const fetchRelease = useAppStore((state) => state.fetchRelease);+ const deleteRelease = useAppStore((state) => state.deleteRelease);+ const undeleteRelease = useAppStore((state) => state.undeleteRelease);const projectV1Store = useProjectV1Store();const projectName = `${projectNamePrefix}${projectId}`;const releaseName = `${projectName}/releases/${releaseId}`;- const release = useVueState(() => releaseStore.getReleaseByName(releaseName));+ const release = useAppStore((state) => state.getReleaseByName(releaseName));const project = useVueState(() =>projectV1Store.getProjectByName(projectName));@@ -57,13 +60,13 @@ export function ProjectReleaseDetailPage({void projectV1Store.getOrFetchProjectByName(projectName).catch((error) => {if (!cancelled) console.error("Failed to fetch project", error);});- void releaseStore.fetchReleaseByName(releaseName).catch((error) => {+ void fetchRelease(releaseName).catch((error) => {if (!cancelled) console.error("Failed to fetch release", error);});return () => {cancelled = true;};- }, [projectV1Store, releaseStore, projectName, releaseName]);+ }, [projectV1Store, fetchRelease, projectName, releaseName]);useEffect(() => {if (project?.title) {@@ -86,7 +89,7 @@ export function ProjectReleaseDetailPage({const handleArchive = async () => {try {- await releaseStore.deleteRelease(release.name);+ await deleteRelease(release.name);} catch (error) {pushNotification({module: "bytebase",@@ -101,7 +104,7 @@ export function ProjectReleaseDetailPage({const handleRestore = async () => {try {- await releaseStore.undeleteRelease(release.name);+ await undeleteRelease(release.name);} catch (error) {pushNotification({module: "bytebase",diff --git a/frontend/src/react/pages/project/ProjectSyncSchemaPage.tsx b/frontend/src/react/pages/project/ProjectSyncSchemaPage.tsxindex 55b05ec6e6..9b84222ca8 100644--- a/frontend/src/react/pages/project/ProjectSyncSchemaPage.tsx+++ b/frontend/src/react/pages/project/ProjectSyncSchemaPage.tsx@@ -47,11 +47,11 @@ import { useEscapeKey } from "@/react/hooks/useEscapeKey";import { useVueState } from "@/react/hooks/useVueState";import { applyPlanTitleToQuery } from "@/react/lib/plan/title";import { cn } from "@/react/lib/utils";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import { PROJECT_V1_ROUTE_PLAN_DETAIL_SPEC_DETAIL } from "@/router/dashboard/projectV1";import {pushNotification,- useChangelogStore,useDatabaseV1Store,useEnvironmentV1Store,useProjectV1Store,@@ -137,7 +137,12 @@ enum Step {export function ProjectSyncSchemaPage({ projectId }: { projectId: string }) {const { t } = useTranslation();- const changelogStore = useChangelogStore();+ const getOrFetchChangelogByName = useAppStore(+ (state) => state.getOrFetchChangelogByName+ );+ const fetchPreviousChangelog = useAppStore(+ (state) => state.fetchPreviousChangelog+ );const databaseStore = useDatabaseV1Store();const projectStore = useProjectV1Store();@@ -225,7 +230,7 @@ export function ProjectSyncSchemaPage({ projectId }: { projectId: string }) {try {if (sourceSchemaType === SourceSchemaType.SCHEMA_HISTORY_VERSION) {if (isValidChangelogName(changelogSource.changelogName)) {- const changelog = await changelogStore.getOrFetchChangelogByName(+ const changelog = await getOrFetchChangelogByName(changelogSource.changelogName || "",ChangelogView.FULL);@@ -255,6 +260,7 @@ export function ProjectSyncSchemaPage({ projectId }: { projectId: string }) {changelogSource.changelogName,changelogSource.databaseName,rawSQLState.statement,+ getOrFetchChangelogByName,]);const sourceEngine = useMemo(() => {@@ -279,7 +285,7 @@ export function ProjectSyncSchemaPage({ projectId }: { projectId: string }) {if (isValidChangelogName(changelogName)) {// Validate the changelog exists before proceeding.- const existing = await changelogStore.getOrFetchChangelogByName(+ const existing = await getOrFetchChangelogByName(changelogName,ChangelogView.BASIC);@@ -289,8 +295,7 @@ export function ProjectSyncSchemaPage({ projectId }: { projectId: string }) {let targetChangelogName: string | undefined = undefined;if (isRollback) {- const previousChangelog =- await changelogStore.fetchPreviousChangelog(changelogName);+ const previousChangelog = await fetchPreviousChangelog(changelogName);if (cancelled) return;if (previousChangelog) {targetChangelogName = previousChangelog.name;@@ -318,7 +323,12 @@ export function ProjectSyncSchemaPage({ projectId }: { projectId: string }) {return () => {cancelled = true;};- }, [projectId]);+ }, [+ databaseStore,+ fetchPreviousChangelog,+ getOrFetchChangelogByName,+ projectId,+ ]);const stepList = useMemo(() => [@@ -747,7 +757,7 @@ function ChangelogSelector({onChange: (value: string) => void;}) {const { t } = useTranslation();- const changelogStore = useChangelogStore();+ const listChangelogs = useAppStore((state) => state.listChangelogs);const databaseStore = useDatabaseV1Store();const [entries, setEntries] = useState<ChangelogEntry[]>([]);const [nextPageToken, setNextPageToken] = useState("");@@ -790,7 +800,7 @@ function ChangelogSelector({(async () => {const { changelogs: fetchedChangelogs, nextPageToken: token } =- await changelogStore.fetchChangelogList({+ await listChangelogs({parent: database,pageSize: getDefaultPagination(),filter: `status == "${Changelog_Status[Changelog_Status.DONE]}"`,@@ -818,22 +828,21 @@ function ChangelogSelector({return () => {cancelled = true;};- }, [database]);+ }, [database, databaseStore, listChangelogs, toEntry]);const loadMore = useCallback(async () => {if (!nextPageToken || !isValidDatabaseName(database) || loadingMore) return;setLoadingMore(true);- const { changelogs: more, nextPageToken: token } =- await changelogStore.fetchChangelogList({- parent: database,- pageToken: nextPageToken,- pageSize: getDefaultPagination(),- filter: `status == "${Changelog_Status[Changelog_Status.DONE]}"`,- });+ const { changelogs: more, nextPageToken: token } = await listChangelogs({+ parent: database,+ pageToken: nextPageToken,+ pageSize: getDefaultPagination(),+ filter: `status == "${Changelog_Status[Changelog_Status.DONE]}"`,+ });setEntries((prev) => [...prev, ...more.map(toEntry)]);setNextPageToken(token);setLoadingMore(false);- }, [nextPageToken, database, loadingMore, toEntry]);+ }, [database, listChangelogs, loadingMore, nextPageToken, toEntry]);const selectedEntry = entries.find((e) => e.name === value);@@ -1168,7 +1177,9 @@ function SelectTargetDatabasesView({onSelectedDatabaseNameChange: (name: string | undefined) => void;}) {const { t } = useTranslation();- const changelogStore = useChangelogStore();+ const getOrFetchChangelogByName = useAppStore(+ (state) => state.getOrFetchChangelogByName+ );const environmentStore = useEnvironmentV1Store();const databaseStore = useDatabaseV1Store();const [isLoadingDiff, setIsLoadingDiff] = useState(false);@@ -1282,11 +1293,10 @@ function SelectTargetDatabasesView({clsRef?.targetChangelogName);if (isRollback) {- const previousChangelog =- await changelogStore.getOrFetchChangelogByName(- clsRef?.targetChangelogName ?? "",- ChangelogView.FULL- );+ const previousChangelog = await getOrFetchChangelogByName(+ clsRef?.targetChangelogName ?? "",+ ChangelogView.FULL+ );newSchemaCache[name] = previousChangelog?.schema ?? "";} else {const schema = await databaseStore.fetchDatabaseSchema(db.name);diff --git a/frontend/src/react/pages/project/ProjectWebhookDetailPage.tsx b/frontend/src/react/pages/project/ProjectWebhookDetailPage.tsxindex 8470bef197..0db73af9d7 100644--- a/frontend/src/react/pages/project/ProjectWebhookDetailPage.tsx+++ b/frontend/src/react/pages/project/ProjectWebhookDetailPage.tsx@@ -1,7 +1,8 @@import { create as createProto } from "@bufbuild/protobuf";import { useMemo } from "react";import { useVueState } from "@/react/hooks/useVueState";-import { useProjectV1Store, useProjectWebhookV1Store } from "@/store";+import { useAppStore } from "@/react/stores/app";+import { useProjectV1Store } from "@/store";import { projectNamePrefix } from "@/store/modules/v1/common";import { State } from "@/types/proto-es/v1/common_pb";import { WebhookSchema } from "@/types/proto-es/v1/project_service_pb";@@ -16,17 +17,16 @@ export function ProjectWebhookDetailPage({webhookResourceId: string;}) {const projectStore = useProjectV1Store();- const projectWebhookV1Store = useProjectWebhookV1Store();+ const getProjectWebhookFromProjectById = useAppStore(+ (state) => state.getProjectWebhookFromProjectById+ );const projectName = `${projectNamePrefix}${projectId}`;const project = useVueState(() => projectStore.getProjectByName(projectName));- const webhook = useVueState(() => {+ const webhook = useMemo(() => {if (!project) return undefined;- return projectWebhookV1Store.getProjectWebhookFromProjectById(- project,- webhookResourceId- );- });+ return getProjectWebhookFromProjectById(project, webhookResourceId);+ }, [project, getProjectWebhookFromProjectById, webhookResourceId]);const allowEdit = useMemo(() => {if (!project) return false;diff --git a/frontend/src/react/pages/project/ProjectWebhookForm.tsx b/frontend/src/react/pages/project/ProjectWebhookForm.tsxindex a0830d1c77..f7e33d44d4 100644--- a/frontend/src/react/pages/project/ProjectWebhookForm.tsx+++ b/frontend/src/react/pages/project/ProjectWebhookForm.tsx@@ -20,6 +20,7 @@ import { Input } from "@/react/components/ui/input";import { Tooltip } from "@/react/components/ui/tooltip";import { WebhookTypeIcon } from "@/react/components/WebhookTypeIcon";import { useVueState } from "@/react/hooks/useVueState";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import {PROJECT_V1_ROUTE_WEBHOOK_DETAIL,@@ -31,7 +32,6 @@ import {pushNotification,useActuatorV1Store,useProjectV1Store,- useProjectWebhookV1Store,useSettingV1Store,} from "@/store";import {@@ -63,8 +63,17 @@ export function ProjectWebhookForm({const { t } = useTranslation();const settingStore = useSettingV1Store();const projectStore = useProjectV1Store();- const projectWebhookV1Store = useProjectWebhookV1Store();const actuatorStore = useActuatorV1Store();+ const createProjectWebhook = useAppStore(+ (state) => state.createProjectWebhook+ );+ const updateProjectWebhook = useAppStore(+ (state) => state.updateProjectWebhook+ );+ const deleteProjectWebhook = useAppStore(+ (state) => state.deleteProjectWebhook+ );+ const testProjectWebhook = useAppStore((state) => state.testProjectWebhook);const [state, setState] = useState<Webhook>(() =>clone(WebhookSchema, webhook)@@ -208,10 +217,7 @@ export function ProjectWebhookForm({const createWebhook = useCallback(() => {withLoading(async () => {- const updatedProject = await projectWebhookV1Store.createProjectWebhook(- project.name,- state- );+ const updatedProject = await createProjectWebhook(project.name, state);projectStore.updateProjectCache({ ...project, ...updatedProject });pushNotification({module: "bytebase",@@ -235,7 +241,7 @@ export function ProjectWebhookForm({});}});- }, [project, state, projectStore, projectWebhookV1Store, t, withLoading]);+ }, [project, state, projectStore, createProjectWebhook, t, withLoading]);const updateWebhook = useCallback(() => {withLoading(async () => {@@ -247,10 +253,7 @@ export function ProjectWebhookForm({if (!isEqual(state.notificationTypes, webhook.notificationTypes))updateMask.push("notification_type");- const updatedProject = await projectWebhookV1Store.updateProjectWebhook(- state,- updateMask- );+ const updatedProject = await updateProjectWebhook(state, updateMask);projectStore.updateProjectCache({ ...project, ...updatedProject });pushNotification({module: "bytebase",@@ -265,7 +268,7 @@ export function ProjectWebhookForm({state,webhook,projectStore,- projectWebhookV1Store,+ updateProjectWebhook,t,withLoading,]);@@ -273,8 +276,7 @@ export function ProjectWebhookForm({const deleteWebhook = useCallback(() => {withLoading(async () => {const name = state.title;- const updatedProject =- await projectWebhookV1Store.deleteProjectWebhook(state);+ const updatedProject = await deleteProjectWebhook(state);projectStore.updateProjectCache({ ...project, ...updatedProject });pushNotification({module: "bytebase",@@ -287,7 +289,7 @@ export function ProjectWebhookForm({project,state,projectStore,- projectWebhookV1Store,+ deleteProjectWebhook,t,withLoading,cancel,@@ -295,10 +297,7 @@ export function ProjectWebhookForm({const testWebhook = useCallback(() => {withLoading(async () => {- const result = await projectWebhookV1Store.testProjectWebhook(- project,- state- );+ const result = await testProjectWebhook(project, state);if (result.error) {pushNotification({module: "bytebase",@@ -315,7 +314,7 @@ export function ProjectWebhookForm({});}});- }, [project, state, projectWebhookV1Store, t, withLoading]);+ }, [project, state, testProjectWebhook, t, withLoading]);const imSettingsUrl = useMemo(() => {return router.resolve({ name: WORKSPACE_ROUTE_IM }).fullPath;diff --git a/frontend/src/react/pages/project/ProjectWebhooksPage.tsx b/frontend/src/react/pages/project/ProjectWebhooksPage.tsxindex c360740df4..a2dc9e5d88 100644--- a/frontend/src/react/pages/project/ProjectWebhooksPage.tsx+++ b/frontend/src/react/pages/project/ProjectWebhooksPage.tsx@@ -24,16 +24,13 @@ import {} from "@/react/components/ui/table";import { WebhookTypeIcon } from "@/react/components/WebhookTypeIcon";import { useVueState } from "@/react/hooks/useVueState";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import {PROJECT_V1_ROUTE_WEBHOOK_CREATE,PROJECT_V1_ROUTE_WEBHOOK_DETAIL,} from "@/router/dashboard/projectV1";-import {- pushNotification,- useProjectV1Store,- useProjectWebhookV1Store,-} from "@/store";+import { pushNotification, useProjectV1Store } from "@/store";import { projectNamePrefix } from "@/store/modules/v1/common";import { projectWebhookV1ActivityItemList } from "@/types";import { State } from "@/types/proto-es/v1/common_pb";@@ -44,7 +41,9 @@ import { extractProjectWebhookID, hasProjectPermissionV2 } from "@/utils";export function ProjectWebhooksPage({ projectId }: { projectId: string }) {const { t } = useTranslation();const projectStore = useProjectV1Store();- const projectWebhookV1Store = useProjectWebhookV1Store();+ const deleteProjectWebhook = useAppStore(+ (state) => state.deleteProjectWebhook+ );const projectName = `${projectNamePrefix}${projectId}`;const project = useVueState(() => projectStore.getProjectByName(projectName));@@ -84,8 +83,7 @@ export function ProjectWebhooksPage({ projectId }: { projectId: string }) {if (!deleteTarget || !project) return;try {const name = deleteTarget.title;- const updatedProject =- await projectWebhookV1Store.deleteProjectWebhook(deleteTarget);+ const updatedProject = await deleteProjectWebhook(deleteTarget);projectStore.updateProjectCache({...project,...updatedProject,@@ -103,7 +101,7 @@ export function ProjectWebhooksPage({ projectId }: { projectId: string }) {});}setDeleteTarget(null);- }, [deleteTarget, project, projectWebhookV1Store, projectStore, t]);+ }, [deleteTarget, project, deleteProjectWebhook, projectStore, t]);return (<div className="py-4 flex flex-col">diff --git a/frontend/src/react/pages/project/database-detail/panels/DatabaseChangelogPanel.tsx b/frontend/src/react/pages/project/database-detail/panels/DatabaseChangelogPanel.tsxindex 69a01ca7bf..cce28c7ebe 100644--- a/frontend/src/react/pages/project/database-detail/panels/DatabaseChangelogPanel.tsx+++ b/frontend/src/react/pages/project/database-detail/panels/DatabaseChangelogPanel.tsx@@ -1,6 +1,6 @@import { useCallback } from "react";import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";-import { useChangelogStore } from "@/store";+import { useAppStore } from "@/react/stores/app";import type {Changelog,Database,@@ -8,7 +8,7 @@ import type {import { DatabaseChangelogTable } from "../changelog/DatabaseChangelogTable";export function DatabaseChangelogPanel({ database }: { database: Database }) {- const changelogStore = useChangelogStore();+ const listChangelogs = useAppStore((state) => state.listChangelogs);const fetchChangelogList = useCallback(async ({pageToken,@@ -17,18 +17,17 @@ export function DatabaseChangelogPanel({ database }: { database: Database }) {pageToken: string;pageSize: number;}) => {- const { nextPageToken, changelogs } =- await changelogStore.fetchChangelogList({- parent: database.name,- pageSize,- pageToken,- });+ const { nextPageToken, changelogs } = await listChangelogs({+ parent: database.name,+ pageSize,+ pageToken,+ });return {nextPageToken,list: changelogs,};},- [changelogStore, database.name]+ [database.name, listChangelogs]);const paged = usePagedData<Changelog>({sessionKey: `bb.paged-changelog-table.${database.name}`,diff --git a/frontend/src/react/pages/project/database-detail/panels/DatabaseRevisionPanel.tsx b/frontend/src/react/pages/project/database-detail/panels/DatabaseRevisionPanel.tsxindex 51122f7c8c..32bc01e985 100644--- a/frontend/src/react/pages/project/database-detail/panels/DatabaseRevisionPanel.tsx+++ b/frontend/src/react/pages/project/database-detail/panels/DatabaseRevisionPanel.tsx@@ -1,7 +1,5 @@-import { create } from "@bufbuild/protobuf";import { useCallback, useEffect, useRef, useState } from "react";import { useTranslation } from "react-i18next";-import { revisionServiceClientConnect } from "@/connect";import {AlertDialog,AlertDialogContent,@@ -11,16 +9,18 @@ import {} from "@/react/components/ui/alert-dialog";import { Button } from "@/react/components/ui/button";import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";-import { useRevisionStore } from "@/store";+import { useAppStore } from "@/react/stores/app";import type { Database } from "@/types/proto-es/v1/database_service_pb";import type { Revision } from "@/types/proto-es/v1/revision_service_pb";-import { ListRevisionsRequestSchema } from "@/types/proto-es/v1/revision_service_pb";import { DatabaseRevisionTable } from "../revision/DatabaseRevisionTable";import { ImportRevisionSheet } from "../revision/ImportRevisionSheet";export function DatabaseRevisionPanel({ database }: { database: Database }) {const { t } = useTranslation();- const revisionStore = useRevisionStore();+ const listRevisionsByDatabase = useAppStore(+ (state) => state.listRevisionsByDatabase+ );+ const deleteRevision = useAppStore((state) => state.deleteRevision);const [showCreateRevisionDrawer, setShowCreateRevisionDrawer] =useState(false);const [selectedNames, setSelectedNames] = useState<Set<string>>(new Set());@@ -32,19 +32,19 @@ export function DatabaseRevisionPanel({ database }: { database: Database }) {pageToken: string;pageSize: number;}) => {- const request = create(ListRevisionsRequestSchema, {- parent: database.name,- pageSize,- pageToken,- });- const { nextPageToken, revisions } =- await revisionServiceClientConnect.listRevisions(request);+ const { nextPageToken, revisions } = await listRevisionsByDatabase(+ database.name,+ {+ pageToken,+ pageSize,+ }+ );return {nextPageToken,list: revisions,};},- [database.name]+ [database.name, listRevisionsByDatabase]);const paged = usePagedData<Revision>({sessionKey: `bb.paged-revision-table.${database.name}`,@@ -68,14 +68,14 @@ export function DatabaseRevisionPanel({ database }: { database: Database }) {const handleDeleteSelected = useCallback(async () => {try {await Promise.allSettled(- [...selectedNames].map((name) => revisionStore.deleteRevision(name))+ [...selectedNames].map((name) => deleteRevision(name)));} finally {setSelectedNames(new Set());setShowDeleteConfirm(false);handleRevisionDeleted();}- }, [selectedNames, handleRevisionDeleted, revisionStore]);+ }, [selectedNames, deleteRevision, handleRevisionDeleted]);// Clear selection on page size change or database switch, but not on loadMore.useEffect(() => {diff --git a/frontend/src/react/pages/project/database-detail/revision/ImportRevisionSheet.tsx b/frontend/src/react/pages/project/database-detail/revision/ImportRevisionSheet.tsxindex 22ef08d3e0..7a6afa4190 100644--- a/frontend/src/react/pages/project/database-detail/revision/ImportRevisionSheet.tsx+++ b/frontend/src/react/pages/project/database-detail/revision/ImportRevisionSheet.tsx@@ -23,12 +23,8 @@ import {SheetTitle,} from "@/react/components/ui/sheet";import { cn } from "@/react/lib/utils";-import {- pushNotification,- useReleaseStore,- useRevisionStore,- useSheetV1Store,-} from "@/store";+import { useAppStore } from "@/react/stores/app";+import { pushNotification, useSheetV1Store } from "@/store";import type {Release,Release_File,@@ -73,8 +69,12 @@ export function ImportRevisionSheet({onCreated: (revisions: Revision[]) => void;}) {const { t } = useTranslation();- const releaseStore = useReleaseStore();- const revisionStore = useRevisionStore();+ const listReleasesByProject = useAppStore(+ (state) => state.listReleasesByProject+ );+ const listAllRevisionsByDatabase = useAppStore(+ (state) => state.listAllRevisionsByDatabase+ );const sheetStore = useSheetV1Store();const fileInputRef = useRef<HTMLInputElement>(null);@@ -94,25 +94,23 @@ export function ImportRevisionSheet({const loadExistingRevisions = useCallback(async () => {try {- const revisions = await revisionStore.fetchAllRevisionsByDatabase(- databaseName,- { pageSize: 1000 }- );+ const revisions = await listAllRevisionsByDatabase(databaseName, {+ pageSize: 1000,+ });setExistingVersions(new Set(revisions.map((revision) => revision.version).filter(Boolean)));} catch (error) {console.error("Failed to load existing revisions:", error);}- }, [databaseName, revisionStore]);+ }, [databaseName, listAllRevisionsByDatabase]);const loadReleases = useCallback(async () => {setLoadingReleases(true);try {- const { releases } = await releaseStore.fetchReleasesByProject(- projectName,- { pageSize: 100 }- );+ const { releases } = await listReleasesByProject(projectName, {+ pageSize: 100,+ });setReleaseList(releases);} catch (error) {pushNotification({@@ -124,7 +122,7 @@ export function ImportRevisionSheet({} finally {setLoadingReleases(false);}- }, [projectName, releaseStore, t]);+ }, [listReleasesByProject, projectName, t]);useEffect(() => {if (!open) {diff --git a/frontend/src/react/pages/project/issue-detail/components/IssueDetailApprovalFlow.tsx b/frontend/src/react/pages/project/issue-detail/components/IssueDetailApprovalFlow.tsxindex f56f6d2d7a..132f22ad13 100644--- a/frontend/src/react/pages/project/issue-detail/components/IssueDetailApprovalFlow.tsx+++ b/frontend/src/react/pages/project/issue-detail/components/IssueDetailApprovalFlow.tsx@@ -15,6 +15,7 @@ import { getAvatarColor, getInitials } from "@/react/components/UserAvatar";import { Button } from "@/react/components/ui/button";import { Tooltip } from "@/react/components/ui/tooltip";import { useVueState } from "@/react/hooks/useVueState";+import { displayRoleTitleFromList } from "@/react/lib/role";import { cn } from "@/react/lib/utils";import { useAppStore } from "@/react/stores/app";import { ensureGroupIdentifier } from "@/react/stores/app/group";@@ -23,7 +24,6 @@ import {useCurrentUserV1,useProjectIamPolicyStore,useProjectV1Store,- useUserStore,} from "@/store";import { projectNamePrefix, userNamePrefix } from "@/store/modules/v1/common";import {@@ -45,7 +45,6 @@ import {groupBindingPrefix,} from "@/types/v1/user";import {- displayRoleTitle,ensureUserFullName,isBindingPolicyExpired,memberMapToRolesInProjectIAM,@@ -298,14 +297,16 @@ function ApprovalStepItem({}function ApprovalUserText({ candidate }: { candidate: string }) {- const userStore = useUserStore();+ const getOrFetchUserByIdentifier = useAppStore(+ (state) => state.getOrFetchUserByIdentifier+ );const [user, setUser] = useState<UserMessage>();useEffect(() => {let canceled = false;const load = async () => {- const next = await userStore.getOrFetchUserByIdentifier({+ const next = await getOrFetchUserByIdentifier({identifier: candidate,});if (canceled || !next) {@@ -326,7 +327,7 @@ function ApprovalUserText({ candidate }: { candidate: string }) {return () => {canceled = true;};- }, [candidate, userStore]);+ }, [candidate, getOrFetchUserByIdentifier]);if (!user) {return null;@@ -500,11 +501,14 @@ function getStatusTag(function useApprovalStep(issue: Issue, step: string, stepIndex: number) {const { t } = useTranslation();+ const roleList = useAppStore((state) => state.roleList);const page = useIssueDetailContext();const currentUser = useVueState(() => useCurrentUserV1().value);const projectStore = useProjectV1Store();const projectIamPolicyStore = useProjectIamPolicyStore();- const userStore = useUserStore();+ const batchGetOrFetchUsers = useAppStore(+ (state) => state.batchGetOrFetchUsers+ );const batchGetOrFetchGroups = useAppStore((state) => state.batchGetOrFetchGroups);@@ -550,9 +554,9 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {const roleName = useMemo(() => {return step- ? displayRoleTitle(step)+ ? displayRoleTitleFromList(step, roleList): t("custom-approval.approval-flow.node.approver");- }, [step, t]);+ }, [roleList, step, t]);const canReRequest = useMemo(() => {return (@@ -648,7 +652,7 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {return;}- const users = await userStore.batchGetOrFetchUsers(+ const users = await batchGetOrFetchUsers(filteredCandidateEmails.map(ensureUserFullName));if (canceled) {@@ -676,7 +680,7 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {return () => {canceled = true;};- }, [currentUserEmail, filteredCandidateEmails, status, userStore]);+ }, [batchGetOrFetchUsers, currentUserEmail, filteredCandidateEmails, status]);const handleReRequestReview = async () => {if (reRequesting) {diff --git a/frontend/src/react/pages/project/issue-detail/components/IssueDetailCommentList.tsx b/frontend/src/react/pages/project/issue-detail/components/IssueDetailCommentList.tsxindex cc0f885e4c..c40753e06e 100644--- a/frontend/src/react/pages/project/issue-detail/components/IssueDetailCommentList.tsx+++ b/frontend/src/react/pages/project/issue-detail/components/IssueDetailCommentList.tsx@@ -30,6 +30,7 @@ import {} from "@/react/components/ui/dialog";import { useVueState } from "@/react/hooks/useVueState";import { cn } from "@/react/lib/utils";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import { buildPlanDeployRouteFromPlanName } from "@/router/dashboard/projectV1RouteHelpers";import {@@ -41,7 +42,6 @@ import {useIssueCommentStore,useProjectV1Store,useSheetV1Store,- useUserStore,} from "@/store";import { projectNamePrefix } from "@/store/modules/v1/common";import { getTimeForPbTimestampProtoEs, unknownUser } from "@/types";@@ -104,7 +104,9 @@ export function IssueDetailCommentList() {const page = useIssueDetailContext();const { setEditing } = page;const projectStore = useProjectV1Store();- const userStore = useUserStore();+ const batchGetOrFetchUsers = useAppStore(+ (state) => state.batchGetOrFetchUsers+ );const issueCommentStore = useIssueCommentStore();const currentUser = useVueState(() => useCurrentUserV1().value);const routeHash = useVueState(() => router.currentRoute.value.hash);@@ -187,8 +189,8 @@ export function IssueDetailCommentList() {if (identifiers.size === 0) {return;}- void userStore.batchGetOrFetchUsers([...identifiers]);- }, [issueComments, page.issue?.creator, userStore]);+ void batchGetOrFetchUsers([...identifiers]);+ }, [batchGetOrFetchUsers, issueComments, page.issue?.creator]);const refreshIssueComments = async () => {if (!issueName) {@@ -360,14 +362,12 @@ function IssueDescriptionCommentRow({const page = useIssueDetailContext();const { setEditing } = page;const projectStore = useProjectV1Store();- const userStore = useUserStore();const projectName = `${projectNamePrefix}${page.projectId}`;const project = useVueState(() => projectStore.getProjectByName(projectName));- const creator = useVueState(- () =>- userStore.getUserByIdentifier(page.issue?.creator || "") ??- unknownUser(page.issue?.creator || "")+ const creatorUser = useAppStore((state) =>+ state.getUserByIdentifier(page.issue?.creator || ""));+ const creator = creatorUser ?? unknownUser(page.issue?.creator || "");const [isEditing, setIsEditing] = useState(false);const [editContent, setEditContent] = useState(page.issue?.description || "");const [isSaving, setIsSaving] = useState(false);@@ -558,12 +558,10 @@ function IssueCommentRow({function CommentActionHeader({ issueComment }: { issueComment: IssueComment }) {const { t } = useTranslation();const page = useIssueDetailContext();- const userStore = useUserStore();- const creator = useVueState(- () =>- userStore.getUserByIdentifier(issueComment.creator) ??- unknownUser(issueComment.creator)+ const creatorUser = useAppStore((state) =>+ state.getUserByIdentifier(issueComment.creator));+ const creator = creatorUser ?? unknownUser(issueComment.creator);const createdTs = getTimeForPbTimestampProtoEs(issueComment.createTime, 0);const updatedTs = getTimeForPbTimestampProtoEs(issueComment.updateTime, 0);const isEdited =@@ -937,12 +935,10 @@ function joinFragments(fragments: ReactNode[], separator: string): ReactNode {function CommentActionIcon({ issueComment }: { issueComment: IssueComment }) {const page = useIssueDetailContext();- const userStore = useUserStore();- const user = useVueState(- () =>- userStore.getUserByIdentifier(issueComment.creator) ??- unknownUser(issueComment.creator)+ const creatorUser = useAppStore((state) =>+ state.getUserByIdentifier(issueComment.creator));+ const user = creatorUser ?? unknownUser(issueComment.creator);const commentType = getIssueCommentType(issueComment);if (diff --git a/frontend/src/react/pages/project/issue-detail/components/IssueDetailRoleGrantDetails.test.tsx b/frontend/src/react/pages/project/issue-detail/components/IssueDetailRoleGrantDetails.test.tsxindex 2387394eb2..b181b9ddb0 100644--- a/frontend/src/react/pages/project/issue-detail/components/IssueDetailRoleGrantDetails.test.tsx+++ b/frontend/src/react/pages/project/issue-detail/components/IssueDetailRoleGrantDetails.test.tsx@@ -68,14 +68,25 @@ vi.mock("@/store", () => ({getEnvironmentByName: () => ({ title: "" }),}),useInstanceV1Store: () => ({ getInstanceByName: () => ({ title: "" }) }),- useRoleStore: () => ({- getRoleByName: (role: string) =>- role === "roles/sqlEditorUser"- ? { name: role, permissions: ["bb.sql.ddl", "bb.sql.dml"] }- : role === "roles/queryOnly"- ? { name: role, permissions: ["bb.sql.select"] }- : undefined,- }),+}));++vi.mock("@/react/stores/app", () => ({+ useAppStore: (selector: (state: unknown) => unknown) =>+ selector({+ roleList: [+ {+ name: "roles/sqlEditorUser",+ permissions: ["bb.sql.ddl", "bb.sql.dml"],+ },+ { name: "roles/queryOnly", permissions: ["bb.sql.select"] },+ ],+ getRoleByName: (role: string) =>+ role === "roles/sqlEditorUser"+ ? { name: role, permissions: ["bb.sql.ddl", "bb.sql.dml"] }+ : role === "roles/queryOnly"+ ? { name: role, permissions: ["bb.sql.select"] }+ : undefined,+ }),}));vi.mock("@/utils", () => ({diff --git a/frontend/src/react/pages/project/issue-detail/components/IssueDetailRoleGrantDetails.tsx b/frontend/src/react/pages/project/issue-detail/components/IssueDetailRoleGrantDetails.tsxindex 9b508dc36b..54102c6613 100644--- a/frontend/src/react/pages/project/issue-detail/components/IssueDetailRoleGrantDetails.tsx+++ b/frontend/src/react/pages/project/issue-detail/components/IssueDetailRoleGrantDetails.tsx@@ -13,14 +13,14 @@ import {import { useEnvironmentList } from "@/react/hooks/useAppState";import { useVueState } from "@/react/hooks/useVueState";import { getRoleEnvironmentLimitationKind } from "@/react/lib/project-member/utils";+import { displayRoleTitleFromList } from "@/react/lib/role";+import { useAppStore } from "@/react/stores/app";import {useDatabaseV1Store,useEnvironmentV1Store,useInstanceV1Store,- useRoleStore,} from "@/store";import type { DatabaseResource } from "@/types";-import { displayRoleTitle } from "@/utils";import {type ConditionExpression,convertFromCELString,@@ -31,12 +31,12 @@ import { useIssueDetailContext } from "../context/IssueDetailContext";export function IssueDetailRoleGrantDetails() {const { t } = useTranslation();const page = useIssueDetailContext();- const roleStore = useRoleStore();const databaseStore = useDatabaseV1Store();const issue = page.issue;const requestRoleName = issue?.roleGrant?.role ?? "";- const requestRole = useVueState(() =>- roleStore.getRoleByName(requestRoleName)+ const roleList = useAppStore((state) => state.roleList);+ const requestRole = useAppStore((state) =>+ state.getRoleByName(requestRoleName));const [condition, setCondition] = useState<ConditionExpression | undefined>();@@ -99,7 +99,9 @@ export function IssueDetailRoleGrantDetails() {{requestRoleName && (<div className="flex flex-col gap-y-2"><span className="text-sm text-control-light">{t("role.self")}</span>- <div className="text-base">{displayRoleTitle(requestRoleName)}</div>+ <div className="text-base">+ {displayRoleTitleFromList(requestRoleName, roleList)}+ </div></div>)}diff --git a/frontend/src/react/pages/project/issue-detail/components/IssueDetailStatementSection.tsx b/frontend/src/react/pages/project/issue-detail/components/IssueDetailStatementSection.tsxindex 59f897cfad..a0ca1939cf 100644--- a/frontend/src/react/pages/project/issue-detail/components/IssueDetailStatementSection.tsx+++ b/frontend/src/react/pages/project/issue-detail/components/IssueDetailStatementSection.tsx@@ -7,15 +7,16 @@ import { MonacoEditor, ReadonlyMonaco } from "@/react/components/monaco";import { ReleaseInfoCard } from "@/react/components/release/ReleaseInfoCard";import { Alert } from "@/react/components/ui/alert";import { Button } from "@/react/components/ui/button";+import { useReleaseByName } from "@/react/hooks/useAppState";import { useVueState } from "@/react/hooks/useVueState";import { cn } from "@/react/lib/utils";+import { useAppStore } from "@/react/stores/app";import {projectNamePrefix,pushNotification,useCurrentUserV1,useDatabaseV1Store,useProjectV1Store,- useReleaseStore,useSheetV1Store,} from "@/store";import { extractUserEmail } from "@/store/modules/v1/common";@@ -61,7 +62,7 @@ export function IssueDetailStatementSection({const page = useIssueDetailContext();const { setEditing } = page;const sheetStore = useSheetV1Store();- const releaseStore = useReleaseStore();+ const fetchRelease = useAppStore((state) => state.fetchRelease);const projectStore = useProjectV1Store();const databaseStore = useDatabaseV1Store();const currentUser = useVueState(() => useCurrentUserV1().value);@@ -73,10 +74,8 @@ export function IssueDetailStatementSection({? spec.config.value.release: "";const sheetName = useMemo(() => sheetNameOfSpec(spec), [spec]);- const release = useVueState(() =>- isValidReleaseName(releaseName)- ? releaseStore.getReleaseByName(releaseName)- : undefined+ const release = useReleaseByName(+ isValidReleaseName(releaseName) ? releaseName : undefined);const [isLoading, setIsLoading] = useState(false);const [isSheetOversize, setIsSheetOversize] = useState(false);@@ -142,13 +141,13 @@ export function IssueDetailStatementSection({const load = async () => {if (isValidReleaseName(releaseName)) {- const cached = releaseStore.getReleaseByName(releaseName);+ const cached = useAppStore.getState().getReleaseByName(releaseName);if (isValidReleaseName(cached.name)) {return;}try {setIsLoading(true);- await releaseStore.fetchReleaseByName(releaseName, true);+ await fetchRelease(releaseName, true);} finally {if (!canceled) {setIsLoading(false);@@ -187,7 +186,7 @@ export function IssueDetailStatementSection({return () => {canceled = true;};- }, [releaseName, releaseStore, sheetName, sheetStore]);+ }, [fetchRelease, releaseName, sheetName, sheetStore]);if (isValidReleaseName(releaseName)) {return (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 324e707741..19abd317c5 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@@ -45,21 +45,15 @@ const mocks = vi.hoisted(() => ({getOrFetchProjectByName: vi.fn(async () => ({})),getProjectByName: vi.fn(() => ({ allowSelfApproval: false })),},- roleStore: {- roleList: [- {- name: "roles/PROJECT_OWNER",- title: "Project Owner",- },- ],- },+ roleList: [+ {+ name: "roles/PROJECT_OWNER",+ title: "Project Owner",+ },+ ],workspaceStore: {roleMapToUsers: new Map(),},- userStore: {- batchGetOrFetchUsers: vi.fn(async () => []),- getOrFetchUserByIdentifier: vi.fn(async () => undefined),- },issueCommentStore: {getIssueComments: vi.fn(() => mocks.comments),listIssueComments: vi.fn(async () => ({ issueComments: mocks.comments })),@@ -91,15 +85,16 @@ vi.mock("@/store", () => ({useCurrentUserV1: () => mocks.currentUserStore,useProjectIamPolicyStore: () => mocks.projectIamPolicyStore,useProjectV1Store: () => mocks.projectStore,- useRoleStore: () => mocks.roleStore,useWorkspaceV1Store: () => mocks.workspaceStore,- useUserStore: () => mocks.userStore,}));vi.mock("@/react/stores/app", () => ({useAppStore: (selector: (state: unknown) => unknown) =>selector({batchGetOrFetchGroups: mocks.batchGetOrFetchGroups,+ batchGetOrFetchUsers: mocks.batchGetOrFetchUsers,+ getOrFetchUserByIdentifier: mocks.getOrFetchUserByIdentifier,+ roleList: mocks.roleList,}),}));@@ -223,8 +218,8 @@ beforeEach(() => {mocks.projectIamPolicyStore.getProjectIamPolicy.mockClear();mocks.projectStore.getOrFetchProjectByName.mockClear();mocks.projectStore.getProjectByName.mockClear();- mocks.userStore.batchGetOrFetchUsers.mockClear();- mocks.userStore.getOrFetchUserByIdentifier.mockClear();+ mocks.batchGetOrFetchUsers.mockClear();+ mocks.getOrFetchUserByIdentifier.mockClear();});describe("PlanDetailApprovalFlow", () => {diff --git a/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.tsx b/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.tsxindex b73de4ec03..2fcb400b16 100644--- a/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.tsx+++ b/frontend/src/react/pages/project/plan-detail/components/PlanDetailApprovalFlow.tsx@@ -15,6 +15,7 @@ import { getAvatarColor, getInitials } from "@/react/components/UserAvatar";import { Button } from "@/react/components/ui/button";import { Tooltip } from "@/react/components/ui/tooltip";import { useVueState } from "@/react/hooks/useVueState";+import { displayRoleTitleFromList } from "@/react/lib/role";import { cn } from "@/react/lib/utils";import { useAppStore } from "@/react/stores/app";import { ensureGroupIdentifier } from "@/react/stores/app/group";@@ -25,7 +26,6 @@ import {useCurrentUserV1,useProjectIamPolicyStore,useProjectV1Store,- useUserStore,} from "@/store";import { projectNamePrefix, userNamePrefix } from "@/store/modules/v1/common";import {@@ -52,7 +52,6 @@ import {groupBindingPrefix,} from "@/types/v1/user";import {- displayRoleTitle,ensureUserFullName,isBindingPolicyExpired,memberMapToRolesInProjectIAM,@@ -467,14 +466,16 @@ function ApprovalStepItem({}function ApprovalUserText({ candidate }: { candidate: string }) {- const userStore = useUserStore();+ const getOrFetchUserByIdentifier = useAppStore(+ (state) => state.getOrFetchUserByIdentifier+ );const [user, setUser] = useState<UserMessage>();useEffect(() => {let canceled = false;const load = async () => {- const next = await userStore.getOrFetchUserByIdentifier({+ const next = await getOrFetchUserByIdentifier({identifier: candidate,});if (canceled || !next) return;@@ -492,7 +493,7 @@ function ApprovalUserText({ candidate }: { candidate: string }) {return () => {canceled = true;};- }, [candidate, userStore]);+ }, [candidate, getOrFetchUserByIdentifier]);if (!user) return null;@@ -661,12 +662,15 @@ function getStatusTag(function useApprovalStep(issue: Issue, step: string, stepIndex: number) {const { t } = useTranslation();+ const roleList = useAppStore((state) => state.roleList);const page = usePlanDetailContext();const { patchState } = page;const currentUser = useCurrentUserV1().value;const projectStore = useProjectV1Store();const projectIamPolicyStore = useProjectIamPolicyStore();- const userStore = useUserStore();+ const batchGetOrFetchUsers = useAppStore(+ (state) => state.batchGetOrFetchUsers+ );const batchGetOrFetchGroups = useAppStore((state) => state.batchGetOrFetchGroups);@@ -715,9 +719,9 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {const roleName = useMemo(() => {return step- ? displayRoleTitle(step)+ ? displayRoleTitleFromList(step, roleList): t("custom-approval.approval-flow.node.approver");- }, [step, t]);+ }, [roleList, step, t]);const canReRequest = useMemo(() => {return (@@ -814,7 +818,7 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {return;}- const users = await userStore.batchGetOrFetchUsers(+ const users = await batchGetOrFetchUsers(filteredCandidateEmails.map(ensureUserFullName));if (canceled) return;@@ -838,7 +842,7 @@ function useApprovalStep(issue: Issue, step: string, stepIndex: number) {return () => {canceled = true;};- }, [currentUserEmail, filteredCandidateEmails, status, userStore]);+ }, [batchGetOrFetchUsers, currentUserEmail, filteredCandidateEmails, status]);const handleReRequestReview = async () => {if (reRequesting) return;diff --git a/frontend/src/react/pages/project/plan-detail/components/deploy/DeployReleaseInfoCard.tsx b/frontend/src/react/pages/project/plan-detail/components/deploy/DeployReleaseInfoCard.tsxindex a765fbe88d..b90693bc5e 100644--- a/frontend/src/react/pages/project/plan-detail/components/deploy/DeployReleaseInfoCard.tsx+++ b/frontend/src/react/pages/project/plan-detail/components/deploy/DeployReleaseInfoCard.tsx@@ -1,5 +1,7 @@+import { useEffect, useState } from "react";import { ReleaseInfoCard } from "@/react/components/release/ReleaseInfoCard";-import { useReleaseByName } from "@/store/modules/release";+import { useReleaseByName } from "@/react/hooks/useAppState";+import { useAppStore } from "@/react/stores/app";export function DeployReleaseInfoCard({className,@@ -8,12 +10,28 @@ export function DeployReleaseInfoCard({className?: string;releaseName: string;}) {- const { release, ready } = useReleaseByName(releaseName);+ const release = useReleaseByName(releaseName);+ const fetchRelease = useAppStore((state) => state.fetchRelease);+ const [ready, setReady] = useState(false);++ useEffect(() => {+ let canceled = false;+ setReady(false);+ void fetchRelease(releaseName, true).finally(() => {+ if (!canceled) {+ setReady(true);+ }+ });+ return () => {+ canceled = true;+ };+ }, [fetchRelease, releaseName]);+return (<ReleaseInfoCardclassName={className}- isLoading={!ready.value}- release={release.value ?? undefined}+ isLoading={!ready}+ release={release}releaseName={releaseName}/>);diff --git a/frontend/src/react/pages/settings/EnvironmentsPage.tsx b/frontend/src/react/pages/settings/EnvironmentsPage.tsxindex 8aeca93e9b..b38b72a6b7 100644--- a/frontend/src/react/pages/settings/EnvironmentsPage.tsx+++ b/frontend/src/react/pages/settings/EnvironmentsPage.tsx@@ -58,6 +58,7 @@ import {import { useEnvironmentList } from "@/react/hooks/useAppState";import { useUnsavedChangesGuard } from "@/react/hooks/useUnsavedChangesGuard";import { useVueState } from "@/react/hooks/useVueState";+import { displayRoleTitleFromList } from "@/react/lib/role";import { cn } from "@/react/lib/utils";import { useAppStore } from "@/react/stores/app";import { router } from "@/router";@@ -71,7 +72,6 @@ import {useDatabaseV1Store,useEnvironmentV1Store,useInstanceV1Store,- useRoleStore,useSQLReviewStore,useSubscriptionV1Store,useUIStateStore,@@ -101,7 +101,6 @@ import {import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";import type { Environment } from "@/types/v1/environment";import {- displayRoleTitle,hasWorkspacePermissionV2,hexToRgb,sqlReviewPolicySlug,@@ -208,9 +207,8 @@ function RolloutPolicyConfig({onChange: (policy: Policy) => void;}) {const { t } = useTranslation();- const roleStore = useRoleStore();const subscriptionStore = useSubscriptionV1Store();- const roleList = useVueState(() => [...roleStore.roleList]);+ const roleList = useAppStore((state) => state.roleList);const hasCustomRoleFeature = useVueState(() =>subscriptionStore.hasInstanceFeature(PlanFeature.FEATURE_CUSTOM_ROLES));@@ -220,6 +218,14 @@ function RolloutPolicyConfig({policy.policy?.case === "rolloutPolicy"? policy.policy.value: create(RolloutPolicySchema);+ const roleByName = useMemo(+ () => new Map(roleList.map((role) => [role.name, role])),+ [roleList]+ );+ const displayPolicyRoleTitle = useCallback(+ (name: string) => displayRoleTitleFromList(name, roleList),+ [roleList]+ );const update = (rp: RolloutPolicy) => {onChange({@@ -267,20 +273,16 @@ function RolloutPolicyConfig({roles: { name: string; title: string }[];}[] = [];- const wsRoles = PRESET_WORKSPACE_ROLES.map((name) =>- roleStore.getRoleByName(name)- )+ const wsRoles = PRESET_WORKSPACE_ROLES.map((name) => roleByName.get(name)).filter((r) => r && !selected.has(r.name))- .map((r) => ({ name: r!.name, title: displayRoleTitle(r!.name) }));+ .map((r) => ({ name: r!.name, title: displayPolicyRoleTitle(r!.name) }));if (wsRoles.length > 0) {groups.push({ label: t("role.workspace-roles.self"), roles: wsRoles });}- const projRoles = PRESET_PROJECT_ROLES.map((name) =>- roleStore.getRoleByName(name)- )+ const projRoles = PRESET_PROJECT_ROLES.map((name) => roleByName.get(name)).filter((r) => r && !selected.has(r.name))- .map((r) => ({ name: r!.name, title: displayRoleTitle(r!.name) }));+ .map((r) => ({ name: r!.name, title: displayPolicyRoleTitle(r!.name) }));if (projRoles.length > 0) {groups.push({ label: t("role.project-roles.self"), roles: projRoles });}@@ -288,7 +290,7 @@ function RolloutPolicyConfig({if (hasCustomRoleFeature) {const customRoles = roleList.filter((r) => !PRESET_ROLES.includes(r.name) && !selected.has(r.name))- .map((r) => ({ name: r.name, title: displayRoleTitle(r.name) }));+ .map((r) => ({ name: r.name, title: displayPolicyRoleTitle(r.name) }));if (customRoles.length > 0) {groups.push({label: t("role.custom-roles.self"),@@ -298,7 +300,14 @@ function RolloutPolicyConfig({}return groups;- }, [roleList, rolloutPolicy.roles, roleStore, t]);+ }, [+ displayPolicyRoleTitle,+ hasCustomRoleFeature,+ roleByName,+ roleList,+ rolloutPolicy.roles,+ t,+ ]);const [showRoleDropdown, setShowRoleDropdown] = useState(false);const dropdownRef = useRef<HTMLDivElement>(null);@@ -328,7 +337,7 @@ function RolloutPolicyConfig({key={role}className="inline-flex items-center gap-x-1 rounded-xs bg-gray-100 px-2 py-1 text-sm">- {displayRoleTitle(role)}+ {displayPolicyRoleTitle(role)}{canUpdatePolicy && (<buttontype="button"diff --git a/frontend/src/react/pages/settings/GroupsPage.tsx b/frontend/src/react/pages/settings/GroupsPage.tsxindex f369f46ecd..7874ebd436 100644--- a/frontend/src/react/pages/settings/GroupsPage.tsx+++ b/frontend/src/react/pages/settings/GroupsPage.tsx@@ -56,7 +56,6 @@ import {useCurrentUserV1,useSettingV1Store,useSubscriptionV1Store,- useUserStore,} from "@/store";import { extractUserEmail, groupNamePrefix } from "@/store/modules/v1/common";import { UNKNOWN_USER_NAME } from "@/types";@@ -118,7 +117,9 @@ function GroupTable({}) {const { t } = useTranslation();const currentUser = useVueState(() => useCurrentUserV1().value);- const userStore = useUserStore();+ const batchGetOrFetchUsers = useAppStore(+ (state) => state.batchGetOrFetchUsers+ );const deleteGroup = useAppStore((state) => state.deleteGroup);const [expandedGroups, setExpandedGroups] = useState<Set<string>>(new Set());@@ -134,8 +135,7 @@ function GroupTable({if (loadingRef.current.has(group.name)) return;loadingRef.current.add(group.name);const memberNames = group.members.map((m) => m.member);- userStore- .batchGetOrFetchUsers(memberNames)+ batchGetOrFetchUsers(memberNames).then((users) => {setMemberCache((prev) => {const next = new Map(prev);@@ -153,7 +153,7 @@ function GroupTable({loadingRef.current.delete(group.name);});},- [userStore]+ [batchGetOrFetchUsers]);// Invalidate member cache when groups data changes (e.g. after editing membership)@@ -486,7 +486,9 @@ function GroupForm({const actuatorStore = useActuatorV1Store();const currentUser = useVueState(() => useCurrentUserV1().value);const isSaaSMode = useVueState(() => actuatorStore.isSaaSMode);- const userStore = useUserStore();+ const getOrFetchUserByIdentifier = useAppStore(+ (state) => state.getOrFetchUserByIdentifier+ );const createGroup = useAppStore((state) => state.createGroup);const updateGroup = useAppStore((state) => state.updateGroup);const deleteGroup = useAppStore((state) => state.deleteGroup);@@ -629,7 +631,7 @@ function GroupForm({if (!isSaaSMode) {const notFound: string[] = [];for (const m of normalizedMembers) {- const user = await userStore.getOrFetchUserByIdentifier({+ const user = await getOrFetchUserByIdentifier({identifier: m.member,silent: true,fallback: false,diff --git a/frontend/src/react/pages/settings/MembersPage.test.tsx b/frontend/src/react/pages/settings/MembersPage.test.tsxindex 5f371f3931..d4c8df5c3e 100644--- a/frontend/src/react/pages/settings/MembersPage.test.tsx+++ b/frontend/src/react/pages/settings/MembersPage.test.tsx@@ -295,9 +295,6 @@ vi.mock("@/store", () => ({state: 1,}),}),- useRoleStore: () => ({- roleList: [{ name: "roles/sqlEditorUser", permissions: [] }],- }),useSettingV1Store: () => ({getOrFetchSettingByName: vi.fn(),getSettingByName: () => undefined,@@ -306,7 +303,6 @@ vi.mock("@/store", () => ({hasFeature: () => true,userCountLimit: 10,}),- useUserStore: () => ({}),useWorkspaceV1Store: () => ({findRolesByMember: () => [],patchIamPolicy: vi.fn(),@@ -314,6 +310,14 @@ vi.mock("@/store", () => ({}),}));+vi.mock("@/react/stores/app", () => ({+ useAppStore: (selector: (state: unknown) => unknown) =>+ selector({+ batchGetOrFetchUsers: vi.fn(async () => []),+ roleList: [{ name: "roles/sqlEditorUser", permissions: [] }],+ }),+}));+vi.mock("./MemberBindingEnvironmentBanner", () => ({MemberBindingEnvironmentBanner: () => null,}));diff --git a/frontend/src/react/pages/settings/MembersPage.tsx b/frontend/src/react/pages/settings/MembersPage.tsxindex 93a6400f0b..d4e1c1d129 100644--- a/frontend/src/react/pages/settings/MembersPage.tsx+++ b/frontend/src/react/pages/settings/MembersPage.tsx@@ -71,22 +71,22 @@ import {getRoleEnvironmentLimitationKind,roleHasDatabaseLimitation,} from "@/react/lib/project-member/utils";+import { displayRoleTitleFromList } from "@/react/lib/role";import { cn } from "@/react/lib/utils";import {useNavigate,WORKSPACE_ROUTE_GROUPS,WORKSPACE_ROUTE_USER_PROFILE,} from "@/react/router";+import { useAppStore } from "@/react/stores/app";import {pushNotification,useActuatorV1Store,useCurrentUserV1,useProjectIamPolicyStore,useProjectV1Store,- useRoleStore,useSettingV1Store,useSubscriptionV1Store,- useUserStore,useWorkspaceV1Store,} from "@/store";import { projectNamePrefix } from "@/store/modules/v1/common";@@ -106,7 +106,6 @@ import type { GroupBinding, MemberBinding } from "@/types/v1/member";import { AccountType, getAccountTypeByEmail } from "@/types/v1/user";import {batchConvertParsedExprToCELString,- displayRoleTitle,formatAbsoluteDateTime,getDatabaseNameOptionConfig,hasProjectPermissionV2,@@ -167,7 +166,10 @@ function MemberTable({const currentUser = useVueState(() => useCurrentUserV1().value);const actuatorStore = useActuatorV1Store();const isSaaSMode = useVueState(() => actuatorStore.isSaaSMode);- const userStore = useUserStore();+ const batchGetOrFetchUsers = useAppStore(+ (state) => state.batchGetOrFetchUsers+ );+ const roleList = useAppStore((state) => state.roleList);const navigate = useNavigate();const canGetGroups = hasWorkspacePermissionV2("bb.groups.get");const canGetUsers = hasWorkspacePermissionV2("bb.users.get");@@ -194,8 +196,7 @@ function MemberTable({if (loadingRef.current.has(group.name)) return;loadingRef.current.add(group.name);const memberNames = group.members.map((m) => m.member);- userStore- .batchGetOrFetchUsers(memberNames)+ batchGetOrFetchUsers(memberNames).then((users: (User | undefined)[]) => {setMemberCache((prev) => {const next = new Map(prev);@@ -211,7 +212,7 @@ function MemberTable({}).finally(() => loadingRef.current.delete(group.name));},- [userStore]+ [batchGetOrFetchUsers]);// Signature of just the group bindings — that's all the cache cares@@ -331,7 +332,7 @@ function MemberTable({return [...groupProjectRoleBindings(active).map((group) => (<Badge key={`active-${group.role}`} className="text-xs gap-x-1">- {displayRoleTitle(group.role)}+ {displayRoleTitleFromList(group.role, roleList)}{group.bindings.length > 1 && (<span className="text-control-light">({group.bindings.length})@@ -344,7 +345,7 @@ function MemberTable({key={`expired-${group.role}`}className="text-xs gap-x-1 line-through opacity-60">- {displayRoleTitle(group.role)}+ {displayRoleTitleFromList(group.role, roleList)}{group.bindings.length > 1 && (<span className="text-control-light">({group.bindings.length})@@ -496,7 +497,7 @@ function MemberTable({: sortRoles([...mb.workspaceLevelRoles]).map((role) => (<Badge key={role} className="text-xs gap-x-1"><Building2 className="h-3 w-3" />- {displayRoleTitle(role)}+ {displayRoleTitleFromList(role, roleList)}</Badge>))}</div>@@ -624,6 +625,7 @@ function MemberTableByRole({const currentUser = useVueState(() => useCurrentUserV1().value);const actuatorStore = useActuatorV1Store();const isSaaSMode = useVueState(() => actuatorStore.isSaaSMode);+ const roleList = useAppStore((state) => state.roleList);const [expandedRoles, setExpandedRoles] = useState<Set<string>>(new Set());const initializedRef = useRef(false);@@ -713,7 +715,7 @@ function MemberTableByRole({<Building2 className="h-4 w-4 text-control-light" />)}<span className="font-medium">- {displayRoleTitle(role)}+ {displayRoleTitleFromList(role, roleList)}</span><span className="text-control-light text-xs">({members.length})@@ -1004,8 +1006,8 @@ function ProjectRoleBindingForm({projectName: string;}) {const { t } = useTranslation();- const roleStore = useRoleStore();- const roleList = useVueState(() => [...roleStore.roleList]);++ const roleList = useAppStore((state) => state.roleList);const expirationPresets = useMemo(() => getExpirationPresets(t), [t]);const factorList = useMemo<Factor[]>(@@ -1241,6 +1243,7 @@ function EditMemberRoleDrawer({const projectIamPolicyStore = useProjectIamPolicyStore();const isSaaSMode = useVueState(() => useActuatorV1Store().isSaaSMode);const settingV1Store = useSettingV1Store();+ const roleList = useAppStore((state) => state.roleList);const hasEmailSetting = useVueState(() => !!settingV1Store.getSettingByName(Setting_SettingName.EMAIL));@@ -1321,7 +1324,7 @@ function EditMemberRoleDrawer({const handleDeleteRole = async (roleBinding: Binding) => {if (!member || !projectName) return;- const roleName = displayRoleTitle(roleBinding.role);+ const roleName = displayRoleTitleFromList(roleBinding.role, roleList);if (!window.confirm(t("project.members.revoke-role-from-member", {@@ -1680,7 +1683,7 @@ function EditMemberRoleDrawer({isExpired && "line-through")}>- {displayRoleTitle(binding.role)}+ {displayRoleTitleFromList(binding.role, roleList)}</span>{isExpired && (<Badge variant="destructive" className="text-xs">diff --git a/frontend/src/react/pages/settings/RequestRoleSheet.test.tsx b/frontend/src/react/pages/settings/RequestRoleSheet.test.tsxindex d6e5e5b498..a322aa1c2a 100644--- a/frontend/src/react/pages/settings/RequestRoleSheet.test.tsx+++ b/frontend/src/react/pages/settings/RequestRoleSheet.test.tsx@@ -222,19 +222,23 @@ vi.mock("@/connect", () => ({vi.mock("@/store", () => ({useCurrentUserV1: () => ({ value: mocks.currentUser }),- useRoleStore: () => ({- getRoleByName: (name: string) => ({- name,- permissions:- name === "roles/projectOwner"- ? ["bb.projects.get", "bb.databases.get"]- : [],- }),- }),useSettingV1Store: () => stableSettingStore,pushNotification: (...args: unknown[]) => mocks.pushNotification(...args),}));+vi.mock("@/react/stores/app", () => ({+ useAppStore: (selector: (state: unknown) => unknown) =>+ selector({+ getRoleByName: (name: string) => ({+ name,+ permissions:+ name === "roles/projectOwner"+ ? ["bb.projects.get", "bb.databases.get"]+ : [],+ }),+ }),+}));+// ---------------------------------------------------------------------------// Import SUT after mocks are registered.// ---------------------------------------------------------------------------diff --git a/frontend/src/react/pages/settings/RequestRoleSheet.tsx b/frontend/src/react/pages/settings/RequestRoleSheet.tsxindex 99b95674ab..0defca0418 100644--- a/frontend/src/react/pages/settings/RequestRoleSheet.tsx+++ b/frontend/src/react/pages/settings/RequestRoleSheet.tsx@@ -35,14 +35,11 @@ import {getRoleEnvironmentLimitationKind,roleHasDatabaseLimitation,} from "@/react/lib/project-member/utils";+import { displayRoleTitleFromList } from "@/react/lib/role";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import { PROJECT_V1_ROUTE_ISSUE_DETAIL } from "@/router/dashboard/projectV1";-import {- pushNotification,- useCurrentUserV1,- useRoleStore,- useSettingV1Store,-} from "@/store";+import { pushNotification, useCurrentUserV1, useSettingV1Store } from "@/store";import type { Permission } from "@/types";import { type DatabaseResource, PresetRoleType } from "@/types";import { ExprSchema as ConditionExprSchema } from "@/types/proto-es/google/type/expr_pb";@@ -56,7 +53,6 @@ import type { Project } from "@/types/proto-es/v1/project_service_pb";import type { Role } from "@/types/proto-es/v1/role_service_pb";import {batchConvertParsedExprToCELString,- displayRoleTitle,extractIssueUID,extractProjectResourceName,formatIssueTitle,@@ -169,9 +165,9 @@ function RequestRoleForm({const [submitting, setSubmitting] = useState(false);const settingStore = useSettingV1Store();- const roleStore = useRoleStore();- const selectedRole = useVueState(() =>- role ? roleStore.getRoleByName(role) : undefined+ const roleList = useAppStore((state) => state.roleList);+ const selectedRole = useAppStore((state) =>+ role ? state.getRoleByName(role) : undefined);const requiredPermissionList = useMemo(() => [...new Set(requiredPermissions)],@@ -402,7 +398,7 @@ function RequestRoleForm({? `[${t("issue.title.request-role")}] ${trimmedReason}`: formatIssueTitle(t("issue.title.request-specific-role", {- role: displayRoleTitle(role),+ role: displayRoleTitleFromList(role, roleList),}),titleDatabaseNames);diff --git a/frontend/src/react/pages/settings/RolesPage.tsx b/frontend/src/react/pages/settings/RolesPage.tsxindex 2417b589aa..9540b18bcf 100644--- a/frontend/src/react/pages/settings/RolesPage.tsx+++ b/frontend/src/react/pages/settings/RolesPage.tsx@@ -48,9 +48,13 @@ import {import { Textarea } from "@/react/components/ui/textarea";import { BlockTooltip } from "@/react/components/ui/tooltip";import { useVueState } from "@/react/hooks/useVueState";+import {+ displayRoleDescriptionFromList,+ displayRoleTitleFromList,+} from "@/react/lib/role";+import { useAppStore } from "@/react/stores/app";import {pushNotification,- useRoleStore,useSubscriptionV1Store,useWorkspaceV1Store,} from "@/store";@@ -64,8 +68,6 @@ import type { Role } from "@/types/proto-es/v1/role_service_pb";import { RoleSchema } from "@/types/proto-es/v1/role_service_pb";import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";import {- displayRoleDescription,- displayRoleTitle,extractRoleResourceName,hasWorkspacePermissionV2,isCustomRole,@@ -211,8 +213,7 @@ function ImportPermissionModal({onImport: (permissions: string[]) => void;}) {const { t } = useTranslation();- const roleStore = useRoleStore();- const roleList = useVueState(() => [...roleStore.roleList]);+ const roleList = useAppStore((state) => state.roleList);const [selectedRoleName, setSelectedRoleName] = useState<string>("");const selectedRole = useMemo(@@ -242,7 +243,7 @@ function ImportPermissionModal({{selectedRole && (<><p className="textinfolabel">- {displayRoleDescription(selectedRole.name)}+ {displayRoleDescriptionFromList(selectedRole.name, roleList)}</p><div><label className="textlabel mb-1 block">@@ -292,13 +293,15 @@ function DeleteConfirmModal({onCancel: () => void;}) {const { t } = useTranslation();+ const roleList = useAppStore((state) => state.roleList);const canDelete = occupiedResources.length === 0;+ const roleTitle = displayRoleTitleFromList(roleName, roleList);return (<AlertDialog open onOpenChange={(nextOpen) => !nextOpen && onCancel()}><AlertDialogContent><AlertDialogTitle>- {t("common.delete")} - {displayRoleTitle(roleName)}+ {t("common.delete")} - {roleTitle}</AlertDialogTitle>{occupiedResources.length > 0 ? (@@ -309,7 +312,7 @@ function DeleteConfirmModal({<><p className="mb-2">{t("resource.delete-warning-with-resources", {- name: displayRoleTitle(roleName),+ name: roleTitle,})}</p><ul className="list-disc pl-4 text-sm">@@ -325,7 +328,7 @@ function DeleteConfirmModal({) : (<AlertDialogDescription className="mt-2">{t("resource.delete-warning", {- name: displayRoleTitle(roleName),+ name: roleTitle,})}</AlertDialogDescription>)}@@ -365,7 +368,8 @@ function RoleSheet({onShowFeatureModal: () => void;}) {const { t } = useTranslation();- const roleStore = useRoleStore();+ const upsertRole = useAppStore((state) => state.upsertRole);+ const roleList = useAppStore((state) => state.roleList);const [editRole, setEditRole] = useState<Role>(create(RoleSchema, { permissions: [...BASIC_WORKSPACE_PERMISSIONS] })@@ -412,10 +416,7 @@ function RoleSheet({const validateResourceId = useCallback(async (val: string) => {- if (- val &&- roleStore.roleList.find((r) => r.name === `${roleNamePrefix}${val}`)- ) {+ if (val && roleList.find((r) => r.name === `${roleNamePrefix}${val}`)) {return [{type: "error" as const,@@ -427,7 +428,7 @@ function RoleSheet({}return [];},- [roleStore.roleList, t]+ [roleList, t]);// Sync incoming role prop to local state@@ -503,7 +504,7 @@ function RoleSheet({setLoading(true);try {- await roleStore.upsertRole(editRole);+ await upsertRole(editRole);pushNotification({module: "bytebase",style: "SUCCESS",@@ -674,7 +675,9 @@ function RoleSheet({export function RolesPage() {const { t } = useTranslation();- const roleStore = useRoleStore();+ const listRoles = useAppStore((state) => state.listRoles);+ const getRoleByName = useAppStore((state) => state.getRoleByName);+ const deleteRole = useAppStore((state) => state.deleteRole);const workspaceStore = useWorkspaceV1Store();const subscriptionStore = useSubscriptionV1Store();@@ -692,7 +695,7 @@ export function RolesPage() {const canCreate = hasWorkspacePermissionV2("bb.roles.create");const canDelete = hasWorkspacePermissionV2("bb.roles.delete");- const roleList = useVueState(() => [...roleStore.roleList]);+ const roleList = useAppStore((state) => state.roleList);const filteredRoleList = useMemo(() => {return sortBy(roleList, (role) =>@@ -704,13 +707,12 @@ export function RolesPage() {// Fetch roles on mount and handle query paramuseEffect(() => {- roleStore- .fetchRoleList()+ listRoles().then(() => {const urlParams = new URLSearchParams(window.location.search);const name = urlParams.get("role");if (name?.startsWith(roleNamePrefix)) {- const role = roleStore.getRoleByName(name);+ const role = getRoleByName(name);if (role) {setDetailRole(role);setDetailMode("EDIT");@@ -748,7 +750,7 @@ export function RolesPage() {const confirmDelete = async () => {if (!deleteTarget) return;try {- await roleStore.deleteRole(deleteTarget);+ await deleteRole(deleteTarget);pushNotification({module: "bytebase",style: "SUCCESS",@@ -819,7 +821,7 @@ export function RolesPage() {{filteredRoleList.map((role) => (<TableRow key={role.name}><TableCell className="whitespace-nowrap">- <span>{displayRoleTitle(role.name)}</span>+ <span>{displayRoleTitleFromList(role.name, roleList)}</span>{!isCustomRole(role.name) && (<Badge variant="secondary" className="ml-2 text-xs">{t("common.system")}@@ -827,9 +829,14 @@ export function RolesPage() {)}</TableCell><TableCell className="text-control-light overflow-hidden">- <BlockTooltip content={displayRoleDescription(role.name)}>+ <BlockTooltip+ content={displayRoleDescriptionFromList(+ role.name,+ roleList+ )}+ ><span className="block truncate">- {displayRoleDescription(role.name)}+ {displayRoleDescriptionFromList(role.name, roleList)}</span></BlockTooltip></TableCell>diff --git a/frontend/src/react/pages/settings/UsersPage.tsx b/frontend/src/react/pages/settings/UsersPage.tsxindex 55f7dc8975..0b74daf290 100644--- a/frontend/src/react/pages/settings/UsersPage.tsx+++ b/frontend/src/react/pages/settings/UsersPage.tsx@@ -54,7 +54,6 @@ import {useCurrentUserV1,useSettingV1Store,useSubscriptionV1Store,- useUserStore,useWorkspaceV1Store,} from "@/store";import { getUserFullNameByType } from "@/store/modules/v1/common";@@ -92,7 +91,8 @@ function UserTable({}) {const { t } = useTranslation();const currentUser = useVueState(() => useCurrentUserV1().value);- const userStore = useUserStore();+ const archiveUser = useAppStore((state) => state.archiveUser);+ const restoreUser = useAppStore((state) => state.restoreUser);const batchGetOrFetchGroups = useAppStore((state) => state.batchGetOrFetchGroups);@@ -132,7 +132,7 @@ function UserTable({} else if (accountType === AccountType.WORKLOAD_IDENTITY) {await deleteWorkloadIdentity(fullName);} else {- await userStore.archiveUser(fullName);+ await archiveUser(fullName);}const updated = create(UserSchema, { ...user, state: State.DELETED });@@ -158,7 +158,7 @@ function UserTable({} else if (accountType === AccountType.WORKLOAD_IDENTITY) {await undeleteWorkloadIdentity(fullName);} else {- await userStore.restoreUser(fullName);+ await restoreUser(fullName);}const updated = create(UserSchema, { ...user, state: State.ACTIVE });@@ -506,7 +506,8 @@ function UserForm({onUpdated,}: Omit<CreateUserSheetProps, "open">) {const { t } = useTranslation();- const userStore = useUserStore();+ const createUser = useAppStore((state) => state.createUser);+ const updateUser = useAppStore((state) => state.updateUser);const workspaceStore = useWorkspaceV1Store();const settingV1Store = useSettingV1Store();@@ -666,7 +667,7 @@ function UserForm({};const handleCreate = async () => {- const createdUser = await userStore.createUser({+ const createdUser = await createUser({...create(UserSchema, {}),title: title || extractUserTitle(email),email,@@ -711,7 +712,7 @@ function UserForm({let updatedUser: User = user;if (updateMask.length > 0) {- updatedUser = await userStore.updateUser(+ updatedUser = await updateUser(create(UpdateUserRequestSchema, {user: payload,updateMask: create(FieldMaskSchema, { paths: updateMask }),@@ -918,7 +919,7 @@ export function UsersPage() {const { t } = useTranslation();const actuatorStore = useActuatorV1Store();const subscriptionStore = useSubscriptionV1Store();- const userStore = useUserStore();+ const listUsers = useAppStore((state) => state.listUsers);const isSaaSMode = useVueState(() => actuatorStore.isSaaSMode);@@ -939,14 +940,14 @@ export function UsersPage() {// Active users paged dataconst fetchActiveUsers = useCallback(async (params: { pageSize: number; pageToken: string }) => {- const result = await userStore.fetchUserList({+ const result = await listUsers({pageSize: params.pageSize,pageToken: params.pageToken,filter: { query: userSearchText },});return { list: result.users, nextPageToken: result.nextPageToken };},- [userStore, userSearchText]+ [listUsers, userSearchText]);const hasUserListPermission = hasWorkspacePermissionV2("bb.users.list");@@ -959,7 +960,7 @@ export function UsersPage() {// Inactive users paged dataconst fetchInactiveUsers = useCallback(async (params: { pageSize: number; pageToken: string }) => {- const result = await userStore.fetchUserList({+ const result = await listUsers({pageSize: params.pageSize,pageToken: params.pageToken,filter: { query: inactiveUserSearchText, state: State.DELETED },@@ -967,7 +968,7 @@ export function UsersPage() {});return { list: result.users, nextPageToken: result.nextPageToken };},- [userStore, inactiveUserSearchText]+ [listUsers, inactiveUserSearchText]);const inactiveUsers = usePagedData<User>({diff --git a/frontend/src/react/pages/settings/profile/ProfilePage.test.tsx b/frontend/src/react/pages/settings/profile/ProfilePage.test.tsxnew file mode 100644index 0000000000..2af6c9288f--- /dev/null+++ b/frontend/src/react/pages/settings/profile/ProfilePage.test.tsx@@ -0,0 +1,282 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import { State } from "@/types/proto-es/v1/common_pb";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++const legacyCurrentUser = {+ name: "users/[email protected]",+ email: "[email protected]",+ title: "Old Alice",+ phone: "",+ password: "",+ state: State.ACTIVE,+ mfaEnabled: false,+ tempRecoveryCodes: [],+};++const updatedCurrentUser = {+ ...legacyCurrentUser,+ title: "New Alice",+};++const mocks = vi.hoisted(() => ({+ useVueState: vi.fn<(getter: () => unknown) => unknown>((getter) => getter()),+ useCurrentUserV1: vi.fn(() => ({ value: legacyCurrentUser })),+ useAuthStore: vi.fn(() => ({+ updateCurrentUserNameForEmailChange: vi.fn(),+ })),+ useSettingV1Store: vi.fn(() => ({+ workspaceProfile: {+ passwordRestriction: undefined,+ requireMfa: false,+ },+ })),+ useWorkspaceV1Store: vi.fn(() => ({+ getWorkspaceRolesByName: vi.fn(() => []),+ })),+ useActuatorV1Store: vi.fn(() => ({+ isSaaSMode: false,+ })),+ hasFeature: vi.fn(() => true),+ pushNotification: vi.fn(),+ getUserByIdentifier: vi.fn(),+ getOrFetchUserByIdentifier: vi.fn(),+ updateUser: vi.fn(async () => updatedCurrentUser),+ updateEmail: vi.fn(),+ routerReplace: vi.fn(),+ routerPush: vi.fn(),+ migrateUserStorage: vi.fn(),+ setDocumentTitle: vi.fn(),+ hasWorkspacePermissionV2: vi.fn(() => true),+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/react/hooks/useUnsavedChangesGuard", () => ({+ useUnsavedChangesGuard: vi.fn(),+}));++vi.mock("@/react/stores/app", () => ({+ useAppStore: (selector: (state: unknown) => unknown) =>+ selector({+ getUserByIdentifier: mocks.getUserByIdentifier,+ getOrFetchUserByIdentifier: mocks.getOrFetchUserByIdentifier,+ updateUser: mocks.updateUser,+ updateEmail: mocks.updateEmail,+ roleList: [],+ }),+}));++vi.mock("@/store", () => ({+ hasFeature: mocks.hasFeature,+ pushNotification: mocks.pushNotification,+ useActuatorV1Store: mocks.useActuatorV1Store,+ useAuthStore: mocks.useAuthStore,+ useCurrentUserV1: mocks.useCurrentUserV1,+ useSettingV1Store: mocks.useSettingV1Store,+ useWorkspaceV1Store: mocks.useWorkspaceV1Store,+}));++vi.mock("@/router", () => ({+ router: {+ replace: mocks.routerReplace,+ push: mocks.routerPush,+ },+}));++vi.mock("@/router/dashboard/workspaceRoutes", async (importOriginal) => {+ const actual =+ await importOriginal<typeof import("@/router/dashboard/workspaceRoutes")>();+ return {+ ...actual,+ WORKSPACE_ROUTE_404: "404",+ WORKSPACE_ROUTE_USER_PROFILE: "user-profile",+ };+});++vi.mock("@/router/dashboard/workspaceSetting", () => ({+ SETTING_ROUTE_PROFILE_TWO_FACTOR: "profile.two-factor",+ SETTING_ROUTE_WORKSPACE_SUBSCRIPTION: "workspace.subscription",+}));++vi.mock("@/utils", () => ({+ hasWorkspacePermissionV2: mocks.hasWorkspacePermissionV2,+ setDocumentTitle: mocks.setDocumentTitle,+ sortRoles: (roles: string[]) => roles,+}));++vi.mock("@/utils/storage-migrate", () => ({+ migrateUserStorage: mocks.migrateUserStorage,+}));++vi.mock("@bufbuild/protobuf", async (importOriginal) => {+ const actual = await importOriginal<typeof import("@bufbuild/protobuf")>();+ return {+ ...actual,+ create: (_schema: unknown, data: Record<string, unknown>) => data,+ };+});++vi.mock("@/react/components/FeatureBadge", () => ({+ FeatureBadge: () => <span data-testid="feature-badge" />,+}));++vi.mock("@/react/components/LearnMoreLink", () => ({+ LearnMoreLink: () => <a href="https://example.com">learn</a>,+}));++vi.mock("@/react/components/ui/button", () => ({+ Button: ({+ children,+ ...props+ }: React.ButtonHTMLAttributes<HTMLButtonElement>) => (+ <button type="button" {...props}>+ {children}+ </button>+ ),+}));++vi.mock("@/react/components/ui/input", () => ({+ Input: ({+ ref,+ ...props+ }: React.InputHTMLAttributes<HTMLInputElement> & {+ ref?: React.Ref<HTMLInputElement>;+ }) => <input ref={ref} {...props} />,+}));++vi.mock("@/react/components/ui/dialog", () => ({+ Dialog: ({ children }: { children: React.ReactNode }) => <>{children}</>,+ DialogContent: ({ children }: { children: React.ReactNode }) => (+ <div>{children}</div>+ ),+ DialogDescription: ({ children }: { children: React.ReactNode }) => (+ <div>{children}</div>+ ),+ DialogTitle: ({ children }: { children: React.ReactNode }) => (+ <div>{children}</div>+ ),+}));++vi.mock("@/react/components/ui/dropdown-menu", () => ({+ DropdownMenu: ({ children }: { children: React.ReactNode }) => (+ <div>{children}</div>+ ),+ DropdownMenuContent: ({ children }: { children: React.ReactNode }) => (+ <div>{children}</div>+ ),+ DropdownMenuItem: ({+ children,+ ...props+ }: React.HTMLAttributes<HTMLDivElement>) => <div {...props}>{children}</div>,+ DropdownMenuTrigger: ({+ children,+ ...props+ }: React.ButtonHTMLAttributes<HTMLButtonElement>) => (+ <button type="button" {...props}>+ {children}+ </button>+ ),+}));++vi.mock("@/react/components/ui/feature-modal", () => ({+ FeatureModal: () => <div data-testid="feature-modal" />,+}));++vi.mock("./EmailInput", () => ({+ EmailInput: ({+ value,+ onChange,+ }: {+ value: string;+ onChange: (value: string) => void;+ }) => <input value={value} onChange={(e) => onChange(e.target.value)} />,+}));++vi.mock("./UserPasswordSection", () => ({+ getPasswordErrors: () => ({ hasHint: false, hasMismatch: false }),+ UserPasswordSection: () => <div data-testid="password-section" />,+}));++vi.mock(+ "@/react/pages/settings/two-factor/RegenerateRecoveryCodesView",+ () => ({+ RegenerateRecoveryCodesView: () => <div data-testid="recovery-codes" />,+ })+);++vi.mock("react-i18next", () => ({+ useTranslation: () => ({+ t: (key: string) => key,+ }),+}));++let ProfilePage: typeof import("./ProfilePage").ProfilePage;++const renderIntoContainer = (element: ReactElement) => {+ const container = document.createElement("div");+ const root = createRoot(container);+ return {+ container,+ render: async () => {+ await act(async () => {+ root.render(element);+ await Promise.resolve();+ });+ },+ unmount: () => {+ act(() => root.unmount());+ container.remove();+ },+ };+};++beforeEach(async () => {+ vi.clearAllMocks();+ ({ ProfilePage } = await import("./ProfilePage"));+});++describe("ProfilePage", () => {+ test("renders the updated self profile from the update response", async () => {+ const { container, render, unmount } = renderIntoContainer(<ProfilePage />);++ await render();+ expect(container.textContent).toContain("Old Alice");++ const edit = [...container.querySelectorAll("button")].find(+ (button) => button.textContent === "common.edit"+ );+ await act(async () => {+ edit?.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });++ const titleInput = container.querySelector("input")!;+ await act(async () => {+ Object.getOwnPropertyDescriptor(+ HTMLInputElement.prototype,+ "value"+ )?.set?.call(titleInput, "New Alice");+ titleInput.dispatchEvent(new Event("input", { bubbles: true }));+ });++ const save = [...container.querySelectorAll("button")].find(+ (button) => button.textContent === "common.save"+ );+ await act(async () => {+ save?.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ await Promise.resolve();+ });++ expect(mocks.updateUser).toHaveBeenCalled();+ expect(container.textContent).toContain("New Alice");++ unmount();+ });+});diff --git a/frontend/src/react/pages/settings/profile/ProfilePage.tsx b/frontend/src/react/pages/settings/profile/ProfilePage.tsxindex f629edc032..8506d0e4fa 100644--- a/frontend/src/react/pages/settings/profile/ProfilePage.tsx+++ b/frontend/src/react/pages/settings/profile/ProfilePage.tsx@@ -25,7 +25,9 @@ import { FeatureModal } from "@/react/components/ui/feature-modal";import { Input } from "@/react/components/ui/input";import { useUnsavedChangesGuard } from "@/react/hooks/useUnsavedChangesGuard";import { useVueState } from "@/react/hooks/useVueState";+import { displayRoleTitleFromList } from "@/react/lib/role";import { RegenerateRecoveryCodesView } from "@/react/pages/settings/two-factor/RegenerateRecoveryCodesView";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import {WORKSPACE_ROUTE_404,@@ -42,7 +44,6 @@ import {useAuthStore,useCurrentUserV1,useSettingV1Store,- useUserStore,useWorkspaceV1Store,} from "@/store";import {@@ -56,12 +57,7 @@ import { State } from "@/types/proto-es/v1/common_pb";import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";import type { User } from "@/types/proto-es/v1/user_service_pb";import { UpdateUserRequestSchema } from "@/types/proto-es/v1/user_service_pb";-import {- displayRoleTitle,- hasWorkspacePermissionV2,- setDocumentTitle,- sortRoles,-} from "@/utils";+import { hasWorkspacePermissionV2, setDocumentTitle, sortRoles } from "@/utils";import { migrateUserStorage } from "@/utils/storage-migrate";import { EmailInput } from "./EmailInput";import { getPasswordErrors, UserPasswordSection } from "./UserPasswordSection";@@ -75,19 +71,23 @@ export function ProfilePage({ principalEmail }: ProfilePageProps) {const authStore = useAuthStore();const settingV1Store = useSettingV1Store();- const userStore = useUserStore();+ const getOrFetchUserByIdentifier = useAppStore(+ (state) => state.getOrFetchUserByIdentifier+ );+ const updateUser = useAppStore((state) => state.updateUser);+ const updateEmail = useAppStore((state) => state.updateEmail);+ const roleList = useAppStore((state) => state.roleList);const workspaceStore = useWorkspaceV1Store();const actuatorStore = useActuatorV1Store();// --- Reactive Vue state ---- const currentUser = useVueState(() => useCurrentUserV1().value);+ const legacyCurrentUser = useVueState(() => useCurrentUserV1().value);+ const [currentUser, setCurrentUser] = useState(legacyCurrentUser);+ const principalUser = useAppStore((state) =>+ principalEmail ? state.getUserByIdentifier(principalEmail) : undefined+ );- const user = useVueState(() => {- if (principalEmail) {- return userStore.getUserByIdentifier(principalEmail) ?? unknownUser();- }- return useCurrentUserV1().value;- });+ const user = principalEmail ? (principalUser ?? unknownUser()) : currentUser;const userRoles = useVueState(() => [...workspaceStore.getWorkspaceRolesByName(user.name),@@ -168,6 +168,10 @@ export function ProfilePage({ principalEmail }: ProfilePageProps) {// --- Effects ---+ useEffect(() => {+ setCurrentUser(legacyCurrentUser);+ }, [legacyCurrentUser]);+// On mount: validate account type and fetch useruseEffect(() => {if (principalEmail) {@@ -177,7 +181,7 @@ export function ProfilePage({ principalEmail }: ProfilePageProps) {return;}(async () => {- const fetched = await userStore.getOrFetchUserByIdentifier({+ const fetched = await getOrFetchUserByIdentifier({identifier: principalEmail,fallback: false,});@@ -243,18 +247,16 @@ export function ProfilePage({ principalEmail }: ProfilePageProps) {try {if (emailChanged) {const oldEmail = user.email;- const updatedUser = await userStore.updateEmail(- oldEmail,- editingUser.email- );+ const updatedUser = await updateEmail(oldEmail, editingUser.email);migrateUserStorage(oldEmail, editingUser.email);if (isSelf) {authStore.updateCurrentUserNameForEmailChange(updatedUser.name);+ setCurrentUser(updatedUser);}}if (updateMaskPaths.length > 0) {- await userStore.updateUser(+ const updatedUser = await updateUser(create(UpdateUserRequestSchema, {user: editingUser,updateMask: create(FieldMaskSchema, {@@ -264,6 +266,9 @@ export function ProfilePage({ principalEmail }: ProfilePageProps) {regenerateTempMfaSecret: false,}));+ if (isSelf) {+ setCurrentUser(updatedUser);+ }}if (emailChanged || updateMaskPaths.length > 0) {@@ -337,7 +342,7 @@ export function ProfilePage({ principalEmail }: ProfilePageProps) {}, [requireMfa, t]);const handleDisable2FA = useCallback(async () => {- await userStore.updateUser(+ const updatedUser = await updateUser(create(UpdateUserRequestSchema, {user: {name: user.name,@@ -348,6 +353,9 @@ export function ProfilePage({ principalEmail }: ProfilePageProps) {}),}));+ if (isSelf) {+ setCurrentUser(updatedUser);+ }setShowDisable2FAConfirm(false);pushNotification({module: "bytebase",@@ -463,7 +471,7 @@ export function ProfilePage({ principalEmail }: ProfilePageProps) {key={role}className="inline-flex items-center rounded-full px-3 py-0.5 text-sm font-medium bg-control-bg text-control">- {displayRoleTitle(role)}+ {displayRoleTitleFromList(role, roleList)}</span>))}</div>diff --git a/frontend/src/react/pages/settings/two-factor/RegenerateRecoveryCodesView.tsx b/frontend/src/react/pages/settings/two-factor/RegenerateRecoveryCodesView.tsxindex d98c0ca64c..84cbe73034 100644--- a/frontend/src/react/pages/settings/two-factor/RegenerateRecoveryCodesView.tsx+++ b/frontend/src/react/pages/settings/two-factor/RegenerateRecoveryCodesView.tsx@@ -4,7 +4,8 @@ import { useCallback, useEffect, useState } from "react";import { useTranslation } from "react-i18next";import { Button } from "@/react/components/ui/button";import { useVueState } from "@/react/hooks/useVueState";-import { pushNotification, useCurrentUserV1, useUserStore } from "@/store";+import { useAppStore } from "@/react/stores/app";+import { pushNotification, useCurrentUserV1 } from "@/store";import { UpdateUserRequestSchema } from "@/types/proto-es/v1/user_service_pb";import { RecoveryCodesView } from "./RecoveryCodesView";@@ -18,12 +19,12 @@ export function RegenerateRecoveryCodesView({onClose,}: RegenerateRecoveryCodesViewProps) {const { t } = useTranslation();- const userStore = useUserStore();+ const updateUser = useAppStore((state) => state.updateUser);const currentUser = useVueState(() => useCurrentUserV1().value);const [recoveryCodesDownloaded, setRecoveryCodesDownloaded] = useState(false);useEffect(() => {- userStore.updateUser(+ updateUser(create(UpdateUserRequestSchema, {user: {name: currentUser.name,@@ -37,7 +38,7 @@ export function RegenerateRecoveryCodesView({}, []);const regenerateRecoveryCodes = useCallback(async () => {- await userStore.updateUser(+ await updateUser(create(UpdateUserRequestSchema, {user: {name: currentUser.name,@@ -54,7 +55,7 @@ export function RegenerateRecoveryCodesView({title: t("two-factor.messages.recovery-codes-regenerated"),});onClose();- }, [currentUser.name, onClose, t, userStore]);+ }, [currentUser.name, onClose, t, updateUser]);return (<>diff --git a/frontend/src/react/pages/settings/two-factor/TwoFactorSetupPage.test.tsx b/frontend/src/react/pages/settings/two-factor/TwoFactorSetupPage.test.tsxnew file mode 100644index 0000000000..c90c2dd54f--- /dev/null+++ b/frontend/src/react/pages/settings/two-factor/TwoFactorSetupPage.test.tsx@@ -0,0 +1,183 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++const currentTimestamp = () => ({+ seconds: BigInt(Math.floor(Date.now() / 1000)),+ nanos: 0,+});++const legacyCurrentUser = {+ name: "users/[email protected]",+ email: "[email protected]",+ tempOtpSecret: "old-secret",+ tempOtpSecretCreatedTime: currentTimestamp(),+ tempRecoveryCodes: [],+};++const regeneratedCurrentUser = {+ ...legacyCurrentUser,+ tempOtpSecret: "new-secret",+ tempOtpSecretCreatedTime: currentTimestamp(),+};++const mocks = vi.hoisted(() => ({+ useVueState: vi.fn<(getter: () => unknown) => unknown>((getter) => getter()),+ useCurrentUserV1: vi.fn(() => ({ value: legacyCurrentUser })),+ updateUser: vi.fn(async () => regeneratedCurrentUser),+ pushNotification: vi.fn(),+ routerReplace: vi.fn(),+ currentRoute: {+ value: { name: "workspace.setting.profile" },+ },+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/react/stores/app", () => ({+ useAppStore: (selector: (state: unknown) => unknown) =>+ selector({+ updateUser: mocks.updateUser,+ }),+}));++vi.mock("@/store", () => ({+ pushNotification: mocks.pushNotification,+ useCurrentUserV1: mocks.useCurrentUserV1,+}));++vi.mock("@/router", () => ({+ router: {+ replace: mocks.routerReplace,+ currentRoute: mocks.currentRoute,+ },+}));++vi.mock("@/router/auth", () => ({+ AUTH_2FA_SETUP_MODULE: "auth.2fa-setup",+}));++vi.mock("@/router/dashboard/workspaceSetting", () => ({+ SETTING_ROUTE_PROFILE: "workspace.setting.profile",+}));++vi.mock("@bufbuild/protobuf", async (importOriginal) => {+ const actual = await importOriginal<typeof import("@bufbuild/protobuf")>();+ return {+ ...actual,+ create: (_schema: unknown, data: Record<string, unknown>) => data,+ };+});++vi.mock("@/types/proto-es/v1/user_service_pb", async (importOriginal) => {+ const actual =+ await importOriginal<+ typeof import("@/types/proto-es/v1/user_service_pb")+ >();+ return {+ ...actual,+ UpdateUserRequestSchema: {},+ };+});++vi.mock("react-i18next", () => ({+ useTranslation: () => ({+ t: (key: string, vars?: Record<string, unknown>) =>+ vars ? `${key}:${JSON.stringify(vars)}` : key,+ }),+}));++vi.mock("qrcode.react", () => ({+ QRCodeSVG: ({ value }: { value: string }) => (+ <div data-testid="qr-code" data-value={value} />+ ),+}));++vi.mock("@/react/components/LearnMoreLink", () => ({+ LearnMoreLink: () => <a href="https://example.com">learn</a>,+}));++vi.mock("@/react/components/ui/button", () => ({+ Button: ({+ children,+ ...props+ }: React.ButtonHTMLAttributes<HTMLButtonElement>) => (+ <button type="button" {...props}>+ {children}+ </button>+ ),+}));++vi.mock("@/react/components/ui/otp-input", () => ({+ OtpInput: () => <div data-testid="otp-input" />,+}));++vi.mock("./RecoveryCodesView", () => ({+ RecoveryCodesView: () => <div data-testid="recovery-codes" />,+}));++vi.mock("./TwoFactorSecretModal", () => ({+ TwoFactorSecretModal: ({ secret }: { secret: string }) => (+ <div data-testid="secret-modal" data-secret={secret} />+ ),+}));++let TwoFactorSetupPage: typeof import("./TwoFactorSetupPage").TwoFactorSetupPage;++const renderIntoContainer = (element: ReactElement) => {+ const container = document.createElement("div");+ const root = createRoot(container);+ return {+ container,+ render: async () => {+ await act(async () => {+ root.render(element);+ await Promise.resolve();+ });+ },+ unmount: () => {+ act(() => root.unmount());+ container.remove();+ },+ };+};++beforeEach(async () => {+ vi.clearAllMocks();+ ({ TwoFactorSetupPage } = await import("./TwoFactorSetupPage"));+});++describe("TwoFactorSetupPage", () => {+ test("renders regenerated MFA secret from the update response", async () => {+ const { container, render, unmount } = renderIntoContainer(+ <TwoFactorSetupPage />+ );++ await render();++ expect(mocks.updateUser).toHaveBeenCalledWith(+ expect.objectContaining({+ regenerateTempMfaSecret: true,+ })+ );+ expect(+ container+ .querySelector('[data-testid="qr-code"]')+ ?.getAttribute("data-value")+ ).toContain("secret=new-secret");+ expect(+ container+ .querySelector('[data-testid="secret-modal"]')+ ?.getAttribute("data-secret")+ ).toBe("new-secret");++ unmount();+ });+});diff --git a/frontend/src/react/pages/settings/two-factor/TwoFactorSetupPage.tsx b/frontend/src/react/pages/settings/two-factor/TwoFactorSetupPage.tsxindex 598d9d6557..ac2aee7efe 100644--- a/frontend/src/react/pages/settings/two-factor/TwoFactorSetupPage.tsx+++ b/frontend/src/react/pages/settings/two-factor/TwoFactorSetupPage.tsx@@ -9,10 +9,11 @@ import { LearnMoreLink } from "@/react/components/LearnMoreLink";import { Button } from "@/react/components/ui/button";import { OtpInput } from "@/react/components/ui/otp-input";import { useVueState } from "@/react/hooks/useVueState";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import { AUTH_2FA_SETUP_MODULE } from "@/router/auth";import { SETTING_ROUTE_PROFILE } from "@/router/dashboard/workspaceSetting";-import { pushNotification, useCurrentUserV1, useUserStore } from "@/store";+import { pushNotification, useCurrentUserV1 } from "@/store";import { UpdateUserRequestSchema } from "@/types/proto-es/v1/user_service_pb";import { RecoveryCodesView } from "./RecoveryCodesView";import { TwoFactorSecretModal } from "./TwoFactorSecretModal";@@ -31,8 +32,9 @@ interface TwoFactorSetupPageProps {export function TwoFactorSetupPage({ cancelAction }: TwoFactorSetupPageProps) {const { t } = useTranslation();- const userStore = useUserStore();- const currentUser = useVueState(() => useCurrentUserV1().value);+ const updateUser = useAppStore((state) => state.updateUser);+ const legacyCurrentUser = useVueState(() => useCurrentUserV1().value);+ const [currentUser, setCurrentUser] = useState(legacyCurrentUser);const [currentStep, setCurrentStep] = useState<Step>(SETUP_AUTH_APP_STEP);const [showSecretModal, setShowSecretModal] = useState(false);@@ -47,6 +49,10 @@ export function TwoFactorSetupPage({ cancelAction }: TwoFactorSetupPageProps) {const currentUserRef = useRef(currentUser);currentUserRef.current = currentUser;+ useEffect(() => {+ setCurrentUser(legacyCurrentUser);+ }, [legacyCurrentUser]);+const stopCountdown = useCallback(() => {if (countdownRef.current) {clearInterval(countdownRef.current);@@ -86,7 +92,7 @@ export function TwoFactorSetupPage({ cancelAction }: TwoFactorSetupPageProps) {}, [updateCountdown, stopCountdown]);const regenerateTempMfaSecret = useCallback(async () => {- await userStore.updateUser(+ const user = await updateUser(create(UpdateUserRequestSchema, {user: {name: currentUser.name,@@ -97,7 +103,8 @@ export function TwoFactorSetupPage({ cancelAction }: TwoFactorSetupPageProps) {regenerateTempMfaSecret: true,}));- }, [currentUser.name, userStore]);+ setCurrentUser(user);+ }, [currentUser.name, updateUser]);// On mount: regenerate secret and start countdownuseEffect(() => {@@ -112,7 +119,7 @@ export function TwoFactorSetupPage({ cancelAction }: TwoFactorSetupPageProps) {const verifyOTPCode = useCallback(async (codes: string[]) => {try {- await userStore.updateUser(+ const user = await updateUser(create(UpdateUserRequestSchema, {user: {name: currentUser.name,@@ -123,6 +130,7 @@ export function TwoFactorSetupPage({ cancelAction }: TwoFactorSetupPageProps) {otpCode: codes.join(""),}));+ setCurrentUser(user);} catch (error) {pushNotification({module: "bytebase",@@ -133,7 +141,7 @@ export function TwoFactorSetupPage({ cancelAction }: TwoFactorSetupPageProps) {}return true;},- [currentUser.name, userStore]+ [currentUser.name, updateUser]);const handleOtpFinish = useCallback(@@ -176,7 +184,7 @@ export function TwoFactorSetupPage({ cancelAction }: TwoFactorSetupPageProps) {}, [cancelAction]);const tryFinishSetup = useCallback(async () => {- await userStore.updateUser(+ await updateUser(create(UpdateUserRequestSchema, {user: {name: currentUser.name,@@ -198,7 +206,7 @@ export function TwoFactorSetupPage({ cancelAction }: TwoFactorSetupPageProps) {} else {router.replace({ name: SETTING_ROUTE_PROFILE });}- }, [currentUser.name, t, userStore]);+ }, [currentUser.name, t, updateUser]);const allowNext =currentStep === SETUP_AUTH_APP_STEPdiff --git a/frontend/src/react/pages/workspace/MyIssuesPage.creators.test.ts b/frontend/src/react/pages/workspace/MyIssuesPage.creators.test.tsnew file mode 100644index 0000000000..4e07a96095--- /dev/null+++ b/frontend/src/react/pages/workspace/MyIssuesPage.creators.test.ts@@ -0,0 +1,14 @@+import { describe, expect, test } from "vitest";++import source from "./MyIssuesPage.tsx?raw";++describe("my issue list creator cache", () => {+ test("fetches listed issue creators before rendering fallback names", () => {+ expect(source).toMatch(+ /const batchGetOrFetchUsers = useAppStore\(\s*\(state\) => state\.batchGetOrFetchUsers\s*\)/+ );+ expect(source).toMatch(+ /batchGetOrFetchUsers\(paged\.dataList\.map\(\(issue\) => issue\.creator\)\)/+ );+ });+});diff --git a/frontend/src/react/pages/workspace/MyIssuesPage.tsx b/frontend/src/react/pages/workspace/MyIssuesPage.tsxindex 2cacccf507..f49b18a850 100644--- a/frontend/src/react/pages/workspace/MyIssuesPage.tsx+++ b/frontend/src/react/pages/workspace/MyIssuesPage.tsx@@ -12,6 +12,7 @@ import {} from "@/react/components/IssueTable";import { PagedTableFooter, usePagedData } from "@/react/hooks/usePagedData";import { useVueState } from "@/react/hooks/useVueState";+import { useAppStore } from "@/react/stores/app";import { router } from "@/router";import { refreshIssueList, useCurrentUserV1, useIssueV1Store } from "@/store";import { ApprovalStatus } from "@/types/proto-es/v1/common_pb";@@ -28,6 +29,9 @@ export function MyIssuesPage() {const { t } = useTranslation();const issueStore = useIssueV1Store();const currentUser = useCurrentUserV1();+ const batchGetOrFetchUsers = useAppStore(+ (state) => state.batchGetOrFetchUsers+ );const me = useVueState(() => currentUser.value);const defaultSearchParams = useCallback((): SearchParams => {@@ -123,6 +127,13 @@ export function MyIssuesPage() {fetchList: fetchIssueList,});+ useEffect(() => {+ if (paged.dataList.length === 0) {+ return;+ }+ void batchGetOrFetchUsers(paged.dataList.map((issue) => issue.creator));+ }, [batchGetOrFetchUsers, paged.dataList]);+// Scope options (no project scope — cross-project)const scopeOptions = useIssueSearchScopeOptions();diff --git a/frontend/src/react/stores/app/changelog.ts b/frontend/src/react/stores/app/changelog.tsnew file mode 100644index 0000000000..15df6ccb3a--- /dev/null+++ b/frontend/src/react/stores/app/changelog.ts@@ -0,0 +1,210 @@+import { create as createProto } from "@bufbuild/protobuf";+import { databaseServiceClientConnect } from "@/connect";+import { UNKNOWN_ID } from "@/types";+import {+ ChangelogView,+ GetChangelogRequestSchema,+ ListChangelogsRequestSchema,+} from "@/types/proto-es/v1/database_service_pb";+import { extractChangelogUID } from "@/utils/v1/changelog";+import type { AppSliceCreator, ChangelogSlice } from "./types";++const changelogCacheKey = (name: string, view: ChangelogView) =>+ `${name}|${view}`;++const normalizeView = (view?: ChangelogView) => view ?? ChangelogView.BASIC;++const changelogListCacheKey = (params: {+ parent: string;+ view?: ChangelogView;+ pageSize?: number;+ pageToken?: string;+ filter?: string;+}) =>+ [+ params.parent,+ normalizeView(params.view),+ params.pageSize ?? 0,+ params.pageToken ?? "",+ params.filter ?? "",+ ].join("|");++export const createChangelogSlice: AppSliceCreator<ChangelogSlice> = (+ set,+ get+) => ({+ changelogsByCacheKey: {},+ changelogsByDatabase: {},+ changelogRequests: {},++ clearChangelogCache: (parent) => {+ set((state) => {+ return {+ changelogsByDatabase: Object.fromEntries(+ Object.entries(state.changelogsByDatabase).filter(+ ([key]) => !key.startsWith(`${parent}|`)+ )+ ),+ };+ });+ },++ listChangelogs: async (params) => {+ const { parent } = params;+ if (!parent) {+ throw new Error('"parent" field is required');+ }++ const view = normalizeView(params.view);+ const listCacheKey = changelogListCacheKey({+ parent,+ pageSize: params.pageSize,+ pageToken: params.pageToken,+ view,+ filter: params.filter,+ });+ const response = await databaseServiceClientConnect.listChangelogs(+ createProto(ListChangelogsRequestSchema, {+ parent,+ pageSize: params.pageSize,+ pageToken: params.pageToken ?? "",+ view,+ filter: params.filter ?? "",+ })+ );+ set((state) => ({+ changelogsByDatabase: {+ ...state.changelogsByDatabase,+ [listCacheKey]: response.changelogs,+ },+ changelogsByCacheKey: {+ ...state.changelogsByCacheKey,+ ...Object.fromEntries(+ response.changelogs.map((changelog) => [+ changelogCacheKey(changelog.name, view),+ changelog,+ ])+ ),+ },+ }));+ return {+ changelogs: response.changelogs,+ nextPageToken: response.nextPageToken,+ };+ },++ getOrFetchChangelogListOfDatabase: async (database, pageSize, view) => {+ const cached =+ get().changelogsByDatabase[+ changelogListCacheKey({+ parent: database,+ pageSize,+ view: normalizeView(view),+ })+ ];+ if (cached) return cached;+ const response = await get().listChangelogs({+ parent: database,+ pageSize,+ view: normalizeView(view),+ });+ return response.changelogs;+ },++ changelogListByDatabase: (database) =>+ Object.entries(get().changelogsByDatabase).find(([key]) => {+ const [parent, view, , pageToken, filter] = key.split("|");+ return (+ parent === database &&+ view === String(ChangelogView.BASIC) &&+ pageToken === "" &&+ filter === ""+ );+ })?.[1] ?? [],++ fetchChangelog: async (params) => {+ if (!params.name) return undefined;+ const view = normalizeView(params.view);+ const changelog = await databaseServiceClientConnect.getChangelog(+ createProto(GetChangelogRequestSchema, {+ name: params.name,+ view,+ })+ );+ set((state) => ({+ changelogsByCacheKey: {+ ...state.changelogsByCacheKey,+ [changelogCacheKey(changelog.name, view)]: changelog,+ },+ }));+ return changelog;+ },++ getOrFetchChangelogByName: async (name, view = ChangelogView.BASIC) => {+ const uid = extractChangelogUID(name);+ if (!uid || uid === String(UNKNOWN_ID)) {+ return undefined;+ }++ const key = changelogCacheKey(name, view);+ const cached = get().changelogsByCacheKey[key];+ if (cached) return cached;+ const pending = get().changelogRequests[key];+ if (pending) return pending;++ const request = get()+ .fetchChangelog({ name, view })+ .finally(() => {+ set((state) => {+ const { [key]: _, ...changelogRequests } = state.changelogRequests;+ return { changelogRequests };+ });+ });+ set((state) => ({+ changelogRequests: { ...state.changelogRequests, [key]: request },+ }));+ return request;+ },++ getChangelogByName: (name, view) => {+ if (view === undefined) {+ return (+ get().changelogsByCacheKey[+ changelogCacheKey(name, ChangelogView.FULL)+ ] ??+ get().changelogsByCacheKey[changelogCacheKey(name, ChangelogView.BASIC)]+ );+ }+ return get().changelogsByCacheKey[changelogCacheKey(name, view)];+ },++ fetchPreviousChangelog: async (name) => {+ const parts = name.split("/changelogs/");+ if (parts.length !== 2) {+ return undefined;+ }+ const database = parts[0];+ const currentUid = extractChangelogUID(name);+ if (!currentUid || currentUid === String(UNKNOWN_ID)) {+ return undefined;+ }++ const { changelogs } = await get().listChangelogs({+ parent: database,+ pageSize: 1000,+ view: ChangelogView.BASIC,+ });+ const index = changelogs.findIndex(+ (changelog) => extractChangelogUID(changelog.name) === currentUid+ );+ if (index < 0 || index === changelogs.length - 1) {+ return undefined;+ }+ return get().getOrFetchChangelogByName(+ changelogs[index + 1].name,+ ChangelogView.FULL+ );+ },+});++export { changelogCacheKey };diff --git a/frontend/src/react/stores/app/iam.ts b/frontend/src/react/stores/app/iam.tsindex f457cee6d2..db105797a2 100644--- a/frontend/src/react/stores/app/iam.ts+++ b/frontend/src/react/stores/app/iam.ts@@ -28,7 +28,11 @@ export const createIamSlice: AppSliceCreator<IamSlice> = (set, get) => ({roleServiceClientConnect.listRoles(createProto(ListRolesRequestSchema, {})).then((response) => {- set({ roles: response.roles, rolesRequest: undefined });+ set({+ roles: response.roles,+ roleList: response.roles,+ rolesRequest: undefined,+ });return response.roles;}).catch(() => {diff --git a/frontend/src/react/stores/app/index.test.ts b/frontend/src/react/stores/app/index.test.tsindex 2d2766c510..ca1131c0e2 100644--- a/frontend/src/react/stores/app/index.test.ts+++ b/frontend/src/react/stores/app/index.test.ts@@ -1,6 +1,7 @@import { create as createProto } from "@bufbuild/protobuf";import { beforeEach, describe, expect, test, vi } from "vitest";import { ReactShellBridgeEvent } from "@/react/shell-bridge";+import { UNKNOWN_PROJECT_NAME } from "@/types";import { ExprSchema } from "@/types/proto-es/google/type/expr_pb";import {AccessGrant_Status,@@ -9,7 +10,11 @@ import {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 {+ ChangelogSchema,+ ChangelogView,+ DatabaseSchema$,+} from "@/types/proto-es/v1/database_service_pb";import { GroupSchema } from "@/types/proto-es/v1/group_service_pb";import {BindingSchema,@@ -18,7 +23,12 @@ import {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 {+ ProjectSchema,+ WebhookSchema,+} from "@/types/proto-es/v1/project_service_pb";+import { ReleaseSchema } from "@/types/proto-es/v1/release_service_pb";+import { RevisionSchema } from "@/types/proto-es/v1/revision_service_pb";import { RoleSchema } from "@/types/proto-es/v1/role_service_pb";import { ServiceAccountSchema } from "@/types/proto-es/v1/service_account_service_pb";import {@@ -35,7 +45,10 @@ import {PlanType,SubscriptionSchema,} from "@/types/proto-es/v1/subscription_service_pb";-import { UserSchema } from "@/types/proto-es/v1/user_service_pb";+import {+ UpdateUserRequestSchema,+ UserSchema,+} from "@/types/proto-es/v1/user_service_pb";import { WorkloadIdentitySchema } from "@/types/proto-es/v1/workload_identity_service_pb";import {storageKeyIntroState,@@ -64,6 +77,8 @@ const mocks = vi.hoisted(() => ({getWorkspace: vi.fn(),getIamPolicy: vi.fn(),listRoles: vi.fn(),+ updateRole: vi.fn(),+ deleteRole: vi.fn(),getSubscription: vi.fn(),uploadLicense: vi.fn(),getSetting: vi.fn(),@@ -72,10 +87,24 @@ const mocks = vi.hoisted(() => ({batchGetProjects: vi.fn(),searchProjects: vi.fn(),createProject: vi.fn(),+ addWebhook: vi.fn(),+ updateWebhook: vi.fn(),+ removeWebhook: vi.fn(),+ testWebhook: vi.fn(),getInstance: vi.fn(),+ listReleases: vi.fn(),+ getRelease: vi.fn(),+ updateRelease: vi.fn(),+ deleteRelease: vi.fn(),+ undeleteRelease: vi.fn(),+ listRevisions: vi.fn(),+ getRevision: vi.fn(),+ deleteRevision: vi.fn(),getDatabase: vi.fn(),batchGetDatabases: vi.fn(),listDatabases: vi.fn(),+ listChangelogs: vi.fn(),+ getChangelog: vi.fn(),getDatabaseGroup: vi.fn(),listDatabaseGroups: vi.fn(),getSheet: vi.fn(),@@ -104,6 +133,14 @@ const mocks = vi.hoisted(() => ({createIdentityProvider: vi.fn(),updateIdentityProvider: vi.fn(),deleteIdentityProvider: vi.fn(),+ listUsers: vi.fn(),+ getUser: vi.fn(),+ batchGetUsers: vi.fn(),+ createUser: vi.fn(),+ updateUser: vi.fn(),+ updateEmail: vi.fn(),+ deleteUser: vi.fn(),+ undeleteUser: vi.fn(),getAccessGrant: vi.fn(),searchMyAccessGrants: vi.fn(),createAccessGrant: vi.fn(),@@ -125,6 +162,22 @@ vi.mock("@/connect", () => ({batchGetProjects: mocks.batchGetProjects,searchProjects: mocks.searchProjects,createProject: mocks.createProject,+ addWebhook: mocks.addWebhook,+ updateWebhook: mocks.updateWebhook,+ removeWebhook: mocks.removeWebhook,+ testWebhook: mocks.testWebhook,+ },+ releaseServiceClientConnect: {+ listReleases: mocks.listReleases,+ getRelease: mocks.getRelease,+ updateRelease: mocks.updateRelease,+ deleteRelease: mocks.deleteRelease,+ undeleteRelease: mocks.undeleteRelease,+ },+ revisionServiceClientConnect: {+ listRevisions: mocks.listRevisions,+ getRevision: mocks.getRevision,+ deleteRevision: mocks.deleteRevision,},instanceServiceClientConnect: {getInstance: mocks.getInstance,@@ -133,6 +186,8 @@ vi.mock("@/connect", () => ({getDatabase: mocks.getDatabase,batchGetDatabases: mocks.batchGetDatabases,listDatabases: mocks.listDatabases,+ listChangelogs: mocks.listChangelogs,+ getChangelog: mocks.getChangelog,},databaseGroupServiceClientConnect: {getDatabaseGroup: mocks.getDatabaseGroup,@@ -186,6 +241,8 @@ vi.mock("@/connect", () => ({},roleServiceClientConnect: {listRoles: mocks.listRoles,+ updateRole: mocks.updateRole,+ deleteRole: mocks.deleteRole,},settingServiceClientConnect: {getSetting: mocks.getSetting,@@ -196,6 +253,14 @@ vi.mock("@/connect", () => ({},userServiceClientConnect: {getCurrentUser: mocks.getCurrentUser,+ listUsers: mocks.listUsers,+ getUser: mocks.getUser,+ batchGetUsers: mocks.batchGetUsers,+ createUser: mocks.createUser,+ updateUser: mocks.updateUser,+ updateEmail: mocks.updateEmail,+ deleteUser: mocks.deleteUser,+ undeleteUser: mocks.undeleteUser,},workspaceServiceClientConnect: {getWorkspace: mocks.getWorkspace,@@ -234,6 +299,32 @@ const groupB = createProto(GroupSchema, {title: "Dev",});+const userA = createProto(UserSchema, {+ name: "users/[email protected]",+ email: "[email protected]",+ title: "Bob",+ state: State.ACTIVE,+});++const userB = createProto(UserSchema, {+ name: "users/[email protected]",+ email: "[email protected]",+ title: "Carol",+ state: State.ACTIVE,+});++const roleA = createProto(RoleSchema, {+ name: "roles/sql-reviewer",+ title: "SQL Reviewer",+ permissions: ["bb.plans.get"],+});++const roleB = createProto(RoleSchema, {+ name: "roles/sql-admin",+ title: "SQL Admin",+ permissions: ["bb.plans.get", "bb.plans.update"],+});+const serviceAccountA = createProto(ServiceAccountSchema, {name: "serviceAccounts/[email protected]",email: "[email protected]",@@ -259,6 +350,39 @@ const accessGrantA = createProto(AccessGrantSchema, {status: AccessGrant_Status.ACTIVE,});+const releaseA = createProto(ReleaseSchema, {+ name: "projects/a/releases/rel-a",+ state: State.ACTIVE,+});++const releaseB = createProto(ReleaseSchema, {+ name: "projects/a/releases/rel-b",+ state: State.ACTIVE,+});++const revisionA = createProto(RevisionSchema, {+ name: "instances/i1/databases/db1/revisions/1",+});++const revisionB = createProto(RevisionSchema, {+ name: "instances/i1/databases/db1/revisions/2",+});++const changelogA = createProto(ChangelogSchema, {+ name: "instances/i1/databases/db1/changelogs/1",+});++const changelogB = createProto(ChangelogSchema, {+ name: "instances/i1/databases/db1/changelogs/2",+ schema: "full",+});++const webhookA = createProto(WebhookSchema, {+ name: "projects/a/webhooks/hook-a",+ title: "Hook A",+ url: "https://example.com/hook-a",+});+const timestampSeconds = (seconds: number) => ({seconds: BigInt(seconds),nanos: 0,@@ -316,6 +440,498 @@ describe("useAppStore", () => {expect(store.getState().groupsByName[groupB.name]).toBe(groupB);});+ test("lists users and populates the user cache", async () => {+ mocks.listUsers.mockResolvedValue({+ users: [userA, userB],+ nextPageToken: "next-user",+ });+ const store = createAppStore();+ store.setState({+ currentUser: user,+ roles: [+ createProto(RoleSchema, {+ name: "roles/user-viewer",+ permissions: ["bb.users.list"],+ }),+ ],+ workspacePolicy: createProto(IamPolicySchema, {+ bindings: [+ createProto(BindingSchema, {+ role: "roles/user-viewer",+ members: [`user:${user.email}`],+ }),+ ],+ }),+ });++ const result = await store.getState().listUsers({+ pageSize: 50,+ filter: { query: "BO", state: State.DELETED },+ });++ expect(result.users).toEqual([userA, userB]);+ expect(result.nextPageToken).toBe("next-user");+ expect(store.getState().usersByName[userA.name]).toBe(userA);+ expect(store.getState().usersByName[userB.name]).toBe(userB);+ expect(mocks.listUsers).toHaveBeenCalledWith(+ expect.objectContaining({+ filter:+ '(name.contains("bo") || email.contains("bo")) && state == "DELETED"',+ showDeleted: true,+ })+ );+ });++ test("listUsers omits the project filter for unknown project sentinels", async () => {+ mocks.listUsers.mockResolvedValue({+ users: [userA],+ nextPageToken: "",+ });+ const store = createAppStore();+ store.setState({+ currentUser: user,+ roles: [+ createProto(RoleSchema, {+ name: "roles/user-viewer",+ permissions: ["bb.users.list"],+ }),+ ],+ workspacePolicy: createProto(IamPolicySchema, {+ bindings: [+ createProto(BindingSchema, {+ role: "roles/user-viewer",+ members: [`user:${user.email}`],+ }),+ ],+ }),+ });++ for (const project of [UNKNOWN_PROJECT_NAME, "projects/-"]) {+ await store.getState().listUsers({+ pageSize: 50,+ filter: { project, query: "BO" },+ });+ }++ expect(+ mocks.listUsers.mock.calls.map(([request]) => request.filter)+ ).toEqual([+ '(name.contains("bo") || email.contains("bo"))',+ '(name.contains("bo") || email.contains("bo"))',+ ]);+ });++ test("batchGetOrFetchUsers fetches missing users and returns unknown fallback", async () => {+ mocks.batchGetUsers.mockResolvedValue({ users: [userB] });+ const store = createAppStore();+ store.setState({ usersByName: { [userA.name]: userA } });++ const result = await store+ .getState()+ .batchGetOrFetchUsers([userA.name, "user:[email protected]"]);++ expect(mocks.batchGetUsers).toHaveBeenCalledWith(+ expect.objectContaining({ names: [userB.name] }),+ expect.anything()+ );+ expect(result.map((u) => u.name)).toEqual([userA.name, userB.name]);++ mocks.batchGetUsers.mockResolvedValueOnce({ users: [] });+ const missing = await store+ .getState()+ .batchGetOrFetchUsers(["users/[email protected]"]);++ expect(missing[0]).toMatchObject({+ name: "users/[email protected]",+ email: "[email protected]",+ });+ });++ test("updateEmail removes the old user cache key and stores the updated user", async () => {+ const updated = createProto(UserSchema, {+ ...userA,+ name: "users/[email protected]",+ email: "[email protected]",+ });+ mocks.updateEmail.mockResolvedValue(updated);+ const store = createAppStore();+ store.setState({ usersByName: { [userA.name]: userA } });++ const result = await store+ .getState()+ .updateEmail("[email protected]", "[email protected]");++ expect(result).toBe(updated);+ expect(store.getState().usersByName[userA.name]).toBeUndefined();+ expect(store.getState().usersByName[updated.name]).toBe(updated);+ });++ test("updateUser passes allowMissing through without requiring an existing user", async () => {+ mocks.updateUser.mockResolvedValue(userA);+ const store = createAppStore();++ const result = await store.getState().updateUser(+ createProto(UpdateUserRequestSchema, {+ user: userA,+ allowMissing: true,+ })+ );++ expect(result).toBe(userA);+ expect(mocks.getUser).not.toHaveBeenCalled();+ expect(mocks.updateUser).toHaveBeenCalledWith(+ expect.objectContaining({+ user: userA,+ allowMissing: true,+ })+ );+ expect(store.getState().usersByName[userA.name]).toBe(userA);+ });++ test("create archive and restore update activated user count when server info is loaded", async () => {+ mocks.createUser.mockResolvedValue(userA);+ mocks.deleteUser.mockResolvedValue({});+ mocks.undeleteUser.mockResolvedValue(userA);+ const store = createAppStore();+ store.setState({+ serverInfo: createProto(ActuatorInfoSchema, {+ activatedUserCount: 2,+ }),+ });++ await store.getState().createUser(userA);+ expect(store.getState().serverInfo?.activatedUserCount).toBe(3);++ await store.getState().archiveUser(userA.name);+ expect(store.getState().serverInfo?.activatedUserCount).toBe(2);++ await store.getState().restoreUser(userA.name);+ expect(store.getState().serverInfo?.activatedUserCount).toBe(3);++ store.setState({+ serverInfo: createProto(ActuatorInfoSchema, {+ activatedUserCount: 0,+ }),+ });++ await store.getState().archiveUser(userA.name);+ expect(store.getState().serverInfo?.activatedUserCount).toBe(0);+ });++ test("lists, upserts, and deletes roles", async () => {+ mocks.listRoles.mockResolvedValue({ roles: [roleA] });+ mocks.updateRole.mockResolvedValue(roleB);+ mocks.deleteRole.mockResolvedValue({});+ const store = createAppStore();++ const roles = await store.getState().listRoles();+ expect(roles).toEqual([roleA]);+ expect(store.getState().getRoleByName(roleA.name)).toBe(roleA);++ const upserted = await store.getState().upsertRole(roleB);+ expect(upserted).toBe(roleB);+ expect(store.getState().roleList).toEqual([roleA, roleB]);+ expect(mocks.updateRole).toHaveBeenCalledWith(+ expect.objectContaining({+ role: roleB,+ updateMask: expect.objectContaining({+ paths: ["title", "description", "permissions"],+ }),+ allowMissing: true,+ })+ );++ await store.getState().deleteRole(roleA);+ expect(store.getState().roleList).toEqual([roleB]);+ expect(mocks.deleteRole).toHaveBeenCalledWith(+ expect.objectContaining({ name: roleA.name })+ );+ });++ test("loads workspace permission roles into the role display cache", async () => {+ mocks.getCurrentUser.mockResolvedValue(user);+ mocks.getActuatorInfo.mockResolvedValue({+ workspace: "workspaces/default",+ });+ mocks.getWorkspace.mockResolvedValue({ name: "workspaces/default" });+ mocks.listRoles.mockResolvedValue({ roles: [roleA, roleB] });+ mocks.getIamPolicy.mockResolvedValue(createProto(IamPolicySchema, {}));+ const store = createAppStore();++ await store.getState().loadWorkspacePermissionState();++ expect(store.getState().roles).toEqual([roleA, roleB]);+ expect(store.getState().roleList).toEqual([roleA, roleB]);+ });++ test("lists releases and marks cached release deleted", async () => {+ mocks.listReleases.mockResolvedValue({+ releases: [releaseA, releaseB],+ nextPageToken: "next-release",+ });+ mocks.deleteRelease.mockResolvedValue({});+ const store = createAppStore();++ const result = await store+ .getState()+ .listReleasesByProject("projects/a", { pageSize: 20 }, true, "x");++ expect(result.releases).toEqual([releaseA, releaseB]);+ expect(result.nextPageToken).toBe("next-release");+ expect(store.getState().releasesByName[releaseA.name]).toBe(releaseA);+ expect(store.getState().getReleasesByProject("projects/a")).toEqual([+ releaseA,+ releaseB,+ ]);+ expect(mocks.listReleases).toHaveBeenCalledWith(+ expect.objectContaining({+ parent: "projects/a",+ pageSize: 20,+ showDeleted: true,+ filter: "x",+ })+ );++ await store.getState().deleteRelease(releaseA.name);++ expect(store.getState().releasesByName[releaseA.name].state).toBe(+ State.DELETED+ );+ });++ test("deduplicates release fetches and clears failed requests", async () => {+ mocks.getRelease.mockResolvedValueOnce(releaseA);+ const store = createAppStore();++ const [first, second] = await Promise.all([+ store.getState().fetchRelease(releaseA.name),+ store.getState().fetchRelease(releaseA.name),+ ]);++ expect(first).toBe(releaseA);+ expect(second).toBe(releaseA);+ expect(mocks.getRelease).toHaveBeenCalledTimes(1);+ expect(store.getState().releaseRequests[releaseA.name]).toBeUndefined();++ const failedName = "projects/a/releases/fail";+ mocks.getRelease.mockRejectedValueOnce(new Error("failed"));+ await expect(store.getState().fetchRelease(failedName)).rejects.toThrow(+ "failed"+ );+ expect(store.getState().releaseRequests[failedName]).toBeUndefined();+ });++ test("paginates all revisions by database and caches results", async () => {+ mocks.listRevisions+ .mockResolvedValueOnce({+ revisions: [revisionA],+ nextPageToken: "next-revision",+ })+ .mockResolvedValueOnce({+ revisions: [revisionB],+ nextPageToken: "",+ });+ const store = createAppStore();++ const result = await store+ .getState()+ .listAllRevisionsByDatabase("instances/i1/databases/db1", {+ pageSize: 1,+ });++ expect(result).toEqual([revisionA, revisionB]);+ expect(mocks.listRevisions.mock.calls.map(([request]) => request)).toEqual([+ expect.objectContaining({+ parent: "instances/i1/databases/db1",+ pageSize: 1,+ pageToken: "",+ }),+ expect.objectContaining({+ parent: "instances/i1/databases/db1",+ pageSize: 1,+ pageToken: "next-revision",+ }),+ ]);+ expect(+ store.getState().getRevisionsByDatabase("instances/i1/databases/db1")+ ).toEqual([revisionA, revisionB]);+ });++ test("deleteRevision removes the cached revision", async () => {+ mocks.deleteRevision.mockResolvedValue({});+ const store = createAppStore();+ store.setState({ revisionsByName: { [revisionA.name]: revisionA } });++ await store.getState().deleteRevision(revisionA.name);++ expect(store.getState().revisionsByName[revisionA.name]).toBeUndefined();+ });++ test("caches changelog list by database and view preference", async () => {+ mocks.listChangelogs.mockResolvedValue({ changelogs: [changelogA] });+ const fullChangelog = createProto(ChangelogSchema, {+ ...changelogA,+ schema: "full",+ });+ const store = createAppStore();++ const changelogs = await store.getState().listChangelogs({+ parent: "instances/i1/databases/db1",+ pageSize: 20,+ view: ChangelogView.BASIC,+ });++ expect(changelogs.changelogs).toEqual([changelogA]);+ expect(+ store.getState().changelogListByDatabase("instances/i1/databases/db1")+ ).toEqual([changelogA]);+ expect(store.getState().getChangelogByName(changelogA.name)).toBe(+ changelogA+ );++ store.setState({+ changelogsByCacheKey: {+ ...store.getState().changelogsByCacheKey,+ [`${changelogA.name}|${ChangelogView.FULL}`]: fullChangelog,+ },+ });++ expect(store.getState().getChangelogByName(changelogA.name)).toBe(+ fullChangelog+ );+ });++ test("keeps changelog list cache isolated by request dimensions", async () => {+ mocks.listChangelogs+ .mockResolvedValueOnce({ changelogs: [changelogA] })+ .mockResolvedValueOnce({ changelogs: [changelogB] });+ const store = createAppStore();++ await store.getState().listChangelogs({+ parent: "instances/i1/databases/db1",+ pageSize: 20,+ view: ChangelogView.BASIC,+ });+ const full = await store+ .getState()+ .getOrFetchChangelogListOfDatabase(+ "instances/i1/databases/db1",+ 20,+ ChangelogView.FULL+ );++ expect(full).toEqual([changelogB]);+ expect(mocks.listChangelogs).toHaveBeenCalledTimes(2);+ expect(+ store.getState().changelogListByDatabase("instances/i1/databases/db1")+ ).toEqual([changelogA]);++ mocks.listChangelogs.mockReset();+ mocks.listChangelogs+ .mockResolvedValueOnce({ changelogs: [changelogB] })+ .mockResolvedValueOnce({ changelogs: [changelogA, changelogB] });+ const filteredStore = createAppStore();++ await filteredStore.getState().listChangelogs({+ parent: "instances/i1/databases/db1",+ pageSize: 20,+ view: ChangelogView.BASIC,+ filter: 'status == "DONE"',+ });+ const unfiltered = await filteredStore+ .getState()+ .getOrFetchChangelogListOfDatabase("instances/i1/databases/db1", 20);++ expect(unfiltered).toEqual([changelogA, changelogB]);+ expect(mocks.listChangelogs).toHaveBeenCalledTimes(2);+ expect(+ filteredStore+ .getState()+ .changelogListByDatabase("instances/i1/databases/db1")+ ).toEqual([changelogA, changelogB]);+ });++ test("deduplicates changelog fetches and skips unknown changelog names", async () => {+ mocks.getChangelog.mockResolvedValue(changelogA);+ const store = createAppStore();++ const missing = await store+ .getState()+ .getOrFetchChangelogByName("instances/i1/databases/db1/changelogs/-1");+ expect(missing).toBeUndefined();++ const [first, second] = await Promise.all([+ store.getState().getOrFetchChangelogByName(changelogA.name),+ store.getState().getOrFetchChangelogByName(changelogA.name),+ ]);++ expect(first).toBe(changelogA);+ expect(second).toBe(changelogA);+ expect(mocks.getChangelog).toHaveBeenCalledTimes(1);+ expect(+ store.getState().changelogRequests[+ `${changelogA.name}|${ChangelogView.BASIC}`+ ]+ ).toBeUndefined();+ });++ test("project webhook operations call through and lookup by id", async () => {+ const projectWithWebhook = createProto(ProjectSchema, {+ ...projectA,+ webhooks: [webhookA],+ });+ mocks.addWebhook.mockResolvedValue(projectWithWebhook);+ mocks.updateWebhook.mockResolvedValue(projectWithWebhook);+ mocks.removeWebhook.mockResolvedValue(projectA);+ mocks.testWebhook.mockResolvedValue({ error: "no route" });+ const store = createAppStore();++ expect(+ store+ .getState()+ .getProjectWebhookFromProjectById(projectWithWebhook, "hook-a")+ ).toBe(webhookA);++ await expect(+ store.getState().createProjectWebhook(projectA.name, webhookA)+ ).resolves.toBe(projectWithWebhook);+ expect(store.getState().projectsByName[projectWithWebhook.name]).toBe(+ projectWithWebhook+ );++ await expect(+ store.getState().updateProjectWebhook(webhookA, ["title"])+ ).resolves.toBe(projectWithWebhook);+ expect(store.getState().projectsByName[projectWithWebhook.name]).toBe(+ projectWithWebhook+ );++ await expect(store.getState().deleteProjectWebhook(webhookA)).resolves.toBe(+ projectA+ );+ expect(store.getState().projectsByName[projectA.name]).toBe(projectA);++ await expect(+ store.getState().testProjectWebhook(projectWithWebhook, webhookA)+ ).resolves.toEqual({ error: "no route" });++ expect(mocks.addWebhook).toHaveBeenCalledWith(+ expect.objectContaining({ project: projectA.name, webhook: webhookA })+ );+ expect(mocks.updateWebhook).toHaveBeenCalledWith(+ expect.objectContaining({+ webhook: webhookA,+ updateMask: expect.objectContaining({ paths: ["title"] }),+ })+ );+ expect(mocks.removeWebhook).toHaveBeenCalledWith(+ expect.objectContaining({ webhook: webhookA })+ );+ expect(mocks.testWebhook).toHaveBeenCalledWith(+ expect.objectContaining({ project: projectA.name, webhook: webhookA })+ );+ });+test("batchGetOrFetchGroups skips cached groups and preserves order", async () => {mocks.batchGetGroups.mockResolvedValue({ groups: [groupB] });const store = createAppStore();diff --git a/frontend/src/react/stores/app/index.ts b/frontend/src/react/stores/app/index.tsindex aa06a939c9..3e1a95a7d9 100644--- a/frontend/src/react/stores/app/index.ts+++ b/frontend/src/react/stores/app/index.ts@@ -1,6 +1,7 @@import { create } from "zustand";import { createAccessGrantSlice } from "./accessGrant";import { createAuthSlice } from "./auth";+import { createChangelogSlice } from "./changelog";import { createDatabaseSlice } from "./database";import { createDBGroupSlice } from "./dbGroup";import { createGroupSlice } from "./group";@@ -11,8 +12,13 @@ import { createInstanceRoleSlice } from "./instanceRole";import { createNotificationSlice } from "./notification";import { createPreferencesSlice } from "./preferences";import { createProjectSlice } from "./project";+import { createProjectWebhookSlice } from "./projectWebhook";+import { createReleaseSlice } from "./release";+import { createRevisionSlice } from "./revision";+import { createRoleSlice } from "./role";import { createServiceAccountSlice } from "./serviceAccount";import { createSheetSlice } from "./sheet";+import { createUserSlice } from "./user";import { createWorkspaceSlice } from "./workspace";import { createWorkloadIdentitySlice } from "./workloadIdentity";@@ -41,6 +47,12 @@ export const createAppStore = () =>...createWorkloadIdentitySlice(...args),...createIdentityProviderSlice(...args),...createAccessGrantSlice(...args),+ ...createUserSlice(...args),+ ...createRoleSlice(...args),+ ...createReleaseSlice(...args),+ ...createRevisionSlice(...args),+ ...createChangelogSlice(...args),+ ...createProjectWebhookSlice(...args),...createNotificationSlice(...args),...createPreferencesSlice(...args),}));diff --git a/frontend/src/react/stores/app/projectWebhook.ts b/frontend/src/react/stores/app/projectWebhook.tsnew file mode 100644index 0000000000..59ab916a81--- /dev/null+++ b/frontend/src/react/stores/app/projectWebhook.ts@@ -0,0 +1,66 @@+import { create as createProto } from "@bufbuild/protobuf";+import { projectServiceClientConnect } from "@/connect";+import {+ AddWebhookRequestSchema,+ RemoveWebhookRequestSchema,+ TestWebhookRequestSchema,+ UpdateWebhookRequestSchema,+} from "@/types/proto-es/v1/project_service_pb";+import { extractProjectWebhookID } from "@/utils";+import type { AppSliceCreator, ProjectWebhookSlice } from "./types";++export const createProjectWebhookSlice: AppSliceCreator<ProjectWebhookSlice> = (+ set+) => ({+ getProjectWebhookFromProjectById: (project, webhookId) => {+ return project.webhooks.find(+ (webhook) => extractProjectWebhookID(webhook.name) === webhookId+ );+ },++ createProjectWebhook: async (project, webhook) => {+ const response = await projectServiceClientConnect.addWebhook(+ createProto(AddWebhookRequestSchema, {+ project,+ webhook,+ })+ );+ set((state) => ({+ projectsByName: { ...state.projectsByName, [response.name]: response },+ }));+ return response;+ },++ updateProjectWebhook: async (webhook, updateMask) => {+ const response = await projectServiceClientConnect.updateWebhook(+ createProto(UpdateWebhookRequestSchema, {+ webhook,+ updateMask: { paths: updateMask },+ })+ );+ set((state) => ({+ projectsByName: { ...state.projectsByName, [response.name]: response },+ }));+ return response;+ },++ deleteProjectWebhook: async (webhook) => {+ const response = await projectServiceClientConnect.removeWebhook(+ createProto(RemoveWebhookRequestSchema, { webhook })+ );+ set((state) => ({+ projectsByName: { ...state.projectsByName, [response.name]: response },+ }));+ return response;+ },++ testProjectWebhook: async (project, webhook) => {+ const response = await projectServiceClientConnect.testWebhook(+ createProto(TestWebhookRequestSchema, {+ project: project.name,+ webhook,+ })+ );+ return { error: response.error };+ },+});diff --git a/frontend/src/react/stores/app/release.ts b/frontend/src/react/stores/app/release.tsnew file mode 100644index 0000000000..5a1397885e--- /dev/null+++ b/frontend/src/react/stores/app/release.ts@@ -0,0 +1,132 @@+import { create as createProto } from "@bufbuild/protobuf";+import { createContextValues } from "@connectrpc/connect";+import { releaseServiceClientConnect } from "@/connect";+import { silentContextKey } from "@/connect/context-key";+import { isValidReleaseName, unknownRelease } from "@/types";+import { State } from "@/types/proto-es/v1/common_pb";+import type { Release } from "@/types/proto-es/v1/release_service_pb";+import {+ DeleteReleaseRequestSchema,+ GetReleaseRequestSchema,+ ListReleasesRequestSchema,+ ReleaseSchema,+ UndeleteReleaseRequestSchema,+ UpdateReleaseRequestSchema,+} from "@/types/proto-es/v1/release_service_pb";+import type { AppSliceCreator, ReleaseSlice } from "./types";++export const createReleaseSlice: AppSliceCreator<ReleaseSlice> = (+ set,+ get+) => ({+ releasesByName: {},+ releaseRequests: {},++ listReleasesByProject: async (project, pagination, showDeleted, filter) => {+ const response = await releaseServiceClientConnect.listReleases(+ createProto(ListReleasesRequestSchema, {+ parent: project,+ pageSize: pagination?.pageSize,+ pageToken: pagination?.pageToken ?? "",+ showDeleted: Boolean(showDeleted),+ filter: filter ?? "",+ })+ );+ set((state) => ({+ releasesByName: {+ ...state.releasesByName,+ ...Object.fromEntries(+ response.releases.map((release) => [release.name, release])+ ),+ },+ }));+ return {+ releases: response.releases,+ nextPageToken: response.nextPageToken,+ };+ },++ fetchRelease: async (name, silent = false) => {+ if (!isValidReleaseName(name)) return undefined;+ const existing = get().releasesByName[name];+ if (existing) return existing;+ const pending = get().releaseRequests[name];+ if (pending) return pending;++ const request = releaseServiceClientConnect+ .getRelease(createProto(GetReleaseRequestSchema, { name }), {+ contextValues: createContextValues().set(silentContextKey, silent),+ })+ .then((release) => {+ set((state) => {+ const { [name]: _, ...releaseRequests } = state.releaseRequests;+ return {+ releasesByName: {+ ...state.releasesByName,+ [release.name]: release,+ },+ releaseRequests,+ };+ });+ return release;+ })+ .catch((error) => {+ set((state) => {+ const { [name]: _, ...releaseRequests } = state.releaseRequests;+ return { releaseRequests };+ });+ throw error;+ });+ set((state) => ({+ releaseRequests: { ...state.releaseRequests, [name]: request },+ }));+ return request;+ },++ getReleasesByProject: (project) => {+ return Object.values(get().releasesByName).filter((release) =>+ release.name.startsWith(`${project}/releases/`)+ );+ },++ getReleaseByName: (name) => get().releasesByName[name] ?? unknownRelease(),++ updateRelease: async (release, updateMask) => {+ const response = await releaseServiceClientConnect.updateRelease(+ createProto(UpdateReleaseRequestSchema, {+ release: createProto(ReleaseSchema, release as Release),+ updateMask: { paths: updateMask },+ })+ );+ set((state) => ({+ releasesByName: { ...state.releasesByName, [response.name]: response },+ }));+ return response;+ },++ deleteRelease: async (name) => {+ await releaseServiceClientConnect.deleteRelease(+ createProto(DeleteReleaseRequestSchema, { name })+ );+ set((state) => {+ const cached = state.releasesByName[name];+ if (!cached) return {};+ return {+ releasesByName: {+ ...state.releasesByName,+ [name]: { ...cached, state: State.DELETED },+ },+ };+ });+ },++ undeleteRelease: async (name) => {+ const response = await releaseServiceClientConnect.undeleteRelease(+ createProto(UndeleteReleaseRequestSchema, { name })+ );+ set((state) => ({+ releasesByName: { ...state.releasesByName, [response.name]: response },+ }));+ return response;+ },+});diff --git a/frontend/src/react/stores/app/revision.ts b/frontend/src/react/stores/app/revision.tsnew file mode 100644index 0000000000..6630c09994--- /dev/null+++ b/frontend/src/react/stores/app/revision.ts@@ -0,0 +1,84 @@+import { create as createProto } from "@bufbuild/protobuf";+import { revisionServiceClientConnect } from "@/connect";+import type { Revision } from "@/types/proto-es/v1/revision_service_pb";+import {+ DeleteRevisionRequestSchema,+ GetRevisionRequestSchema,+ ListRevisionsRequestSchema,+} from "@/types/proto-es/v1/revision_service_pb";+import type { AppSliceCreator, RevisionSlice } from "./types";++const revisionNamePrefix = "revisions/";++export const createRevisionSlice: AppSliceCreator<RevisionSlice> = (+ set,+ get+) => ({+ revisionsByName: {},++ listRevisionsByDatabase: async (database, pagination) => {+ const response = await revisionServiceClientConnect.listRevisions(+ createProto(ListRevisionsRequestSchema, {+ parent: database,+ pageSize: pagination?.pageSize,+ pageToken: pagination?.pageToken ?? "",+ })+ );+ set((state) => ({+ revisionsByName: {+ ...state.revisionsByName,+ ...Object.fromEntries(+ response.revisions.map((revision) => [revision.name, revision])+ ),+ },+ }));+ return {+ revisions: response.revisions,+ nextPageToken: response.nextPageToken,+ };+ },++ listAllRevisionsByDatabase: async (database, pagination) => {+ const revisions: Revision[] = [];+ let pageToken = "";+ do {+ const response = await get().listRevisionsByDatabase(database, {+ pageSize: pagination?.pageSize,+ pageToken,+ });+ revisions.push(...response.revisions);+ pageToken = response.nextPageToken;+ } while (pageToken);+ return revisions;+ },++ fetchRevision: async (name) => {+ const cached = get().revisionsByName[name];+ if (cached) return cached;+ const revision = await revisionServiceClientConnect.getRevision(+ createProto(GetRevisionRequestSchema, { name })+ );+ set((state) => ({+ revisionsByName: { ...state.revisionsByName, [revision.name]: revision },+ }));+ return revision;+ },++ getRevisionsByDatabase: (database) => {+ return Object.values(get().revisionsByName).filter((revision) =>+ revision.name.startsWith(`${database}/${revisionNamePrefix}`)+ );+ },++ getRevisionByName: (name) => get().revisionsByName[name],++ deleteRevision: async (name) => {+ await revisionServiceClientConnect.deleteRevision(+ createProto(DeleteRevisionRequestSchema, { name })+ );+ set((state) => {+ const { [name]: _, ...revisionsByName } = state.revisionsByName;+ return { revisionsByName };+ });+ },+});diff --git a/frontend/src/react/stores/app/role.ts b/frontend/src/react/stores/app/role.tsnew file mode 100644index 0000000000..4224851372--- /dev/null+++ b/frontend/src/react/stores/app/role.ts@@ -0,0 +1,53 @@+import { create as createProto } from "@bufbuild/protobuf";+import { roleServiceClientConnect } from "@/connect";+import {+ DeleteRoleRequestSchema,+ ListRolesRequestSchema,+ UpdateRoleRequestSchema,+} from "@/types/proto-es/v1/role_service_pb";+import type { AppSliceCreator, RoleSlice } from "./types";++export const createRoleSlice: AppSliceCreator<RoleSlice> = (set, get) => ({+ roleList: [],++ listRoles: async () => {+ const response = await roleServiceClientConnect.listRoles(+ createProto(ListRolesRequestSchema, {})+ );+ set({ roleList: response.roles });+ return response.roles;+ },++ getRoleByName: (name) => get().roleList.find((role) => role.name === name),++ upsertRole: async (role) => {+ const response = await roleServiceClientConnect.updateRole(+ createProto(UpdateRoleRequestSchema, {+ role,+ updateMask: {+ paths: ["title", "description", "permissions"],+ },+ allowMissing: true,+ })+ );+ set((state) => {+ const index = state.roleList.findIndex((r) => r.name === role.name);+ if (index < 0) {+ return { roleList: [...state.roleList, response] };+ }+ const roleList = [...state.roleList];+ roleList.splice(index, 1, response);+ return { roleList };+ });+ return response;+ },++ deleteRole: async (role) => {+ await roleServiceClientConnect.deleteRole(+ createProto(DeleteRoleRequestSchema, { name: role.name })+ );+ set((state) => ({+ roleList: state.roleList.filter((r) => r.name !== role.name),+ }));+ },+});diff --git a/frontend/src/react/stores/app/types.ts b/frontend/src/react/stores/app/types.tsindex 7554b84272..b173f488ed 100644--- a/frontend/src/react/stores/app/types.ts+++ b/frontend/src/react/stores/app/types.ts@@ -6,7 +6,13 @@ 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 {+ Changelog,+ ChangelogView,+ Database,+ GetChangelogRequest,+ ListChangelogsRequest,+} 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";@@ -15,7 +21,9 @@ import type {Instance,InstanceResource,} from "@/types/proto-es/v1/instance_service_pb";-import type { Project } from "@/types/proto-es/v1/project_service_pb";+import type { Project, Webhook } from "@/types/proto-es/v1/project_service_pb";+import type { Release } from "@/types/proto-es/v1/release_service_pb";+import type { Revision } from "@/types/proto-es/v1/revision_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";@@ -25,7 +33,10 @@ import type {PlanType,Subscription,} from "@/types/proto-es/v1/subscription_service_pb";-import type { User } from "@/types/proto-es/v1/user_service_pb";+import type {+ UpdateUserRequest,+ 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";@@ -47,6 +58,19 @@ export type AccountFilter = {state?: State;};+export type UserFilter = {+ query?: string;+ project?: string;+ state?: State;+};++export type ListUsersParams = {+ pageSize: number;+ pageToken?: string;+ filter?: UserFilter;+ showDeleted?: boolean;+};+export type ListServiceAccountsParams = {parent: string;pageSize: number;@@ -334,6 +358,119 @@ export type AccessGrantSlice = {revokeAccessGrant: (name: string) => Promise<AccessGrant>;};+export type UserSlice = {+ usersByName: Record<string, User>;+ userRequests: Record<string, Promise<User | undefined>>;+ listUsers: (+ params: ListUsersParams+ ) => Promise<{ users: User[]; nextPageToken: string }>;+ fetchUser: (name: string, silent?: boolean) => Promise<User | undefined>;+ batchGetOrFetchUsers: (names: string[]) => Promise<User[]>;+ getOrFetchUserByIdentifier: (params: {+ identifier: string;+ silent?: boolean;+ fallback?: boolean;+ }) => Promise<User>;+ getUserByIdentifier: (identifier: string) => User | undefined;+ createUser: (user: User) => Promise<User>;+ updateUser: (request: UpdateUserRequest) => Promise<User>;+ updateEmail: (oldEmail: string, newEmail: string) => Promise<User>;+ archiveUser: (name: string) => Promise<void>;+ restoreUser: (name: string) => Promise<User>;+};++export type RoleSlice = {+ roleList: Role[];+ listRoles: () => Promise<Role[]>;+ getRoleByName: (name: string) => Role | undefined;+ upsertRole: (role: Role) => Promise<Role>;+ deleteRole: (role: Role) => Promise<void>;+};++export type ReleaseSlice = {+ releasesByName: Record<string, Release>;+ releaseRequests: Record<string, Promise<Release | undefined>>;+ listReleasesByProject: (+ project: string,+ pagination?: { pageSize?: number; pageToken?: string },+ showDeleted?: boolean,+ filter?: string+ ) => Promise<{ releases: Release[]; nextPageToken: string }>;+ fetchRelease: (+ name: string,+ silent?: boolean+ ) => Promise<Release | undefined>;+ getReleasesByProject: (project: string) => Release[];+ getReleaseByName: (name: string) => Release;+ updateRelease: (+ release: Partial<Release>,+ updateMask: string[]+ ) => Promise<Release>;+ deleteRelease: (name: string) => Promise<void>;+ undeleteRelease: (name: string) => Promise<Release>;+};++export type RevisionSlice = {+ revisionsByName: Record<string, Revision>;+ listRevisionsByDatabase: (+ database: string,+ pagination?: { pageSize?: number; pageToken?: string }+ ) => Promise<{ revisions: Revision[]; nextPageToken: string }>;+ listAllRevisionsByDatabase: (+ database: string,+ pagination?: { pageSize?: number }+ ) => Promise<Revision[]>;+ fetchRevision: (name: string) => Promise<Revision>;+ getRevisionsByDatabase: (database: string) => Revision[];+ getRevisionByName: (name: string) => Revision | undefined;+ deleteRevision: (name: string) => Promise<void>;+};++export type ChangelogSlice = {+ changelogsByCacheKey: Record<string, Changelog>;+ changelogsByDatabase: Record<string, Changelog[]>;+ changelogRequests: Record<string, Promise<Changelog | undefined>>;+ clearChangelogCache: (parent: string) => void;+ listChangelogs: (+ params: Partial<ListChangelogsRequest>+ ) => Promise<{ changelogs: Changelog[]; nextPageToken: string }>;+ getOrFetchChangelogListOfDatabase: (+ database: string,+ pageSize: number,+ view?: ChangelogView+ ) => Promise<Changelog[]>;+ changelogListByDatabase: (database: string) => Changelog[];+ fetchChangelog: (+ params: Partial<GetChangelogRequest>+ ) => Promise<Changelog | undefined>;+ getOrFetchChangelogByName: (+ name: string,+ view?: ChangelogView+ ) => Promise<Changelog | undefined>;+ getChangelogByName: (+ name: string,+ view?: ChangelogView+ ) => Changelog | undefined;+ fetchPreviousChangelog: (name: string) => Promise<Changelog | undefined>;+};++export type ProjectWebhookSlice = {+ getProjectWebhookFromProjectById: (+ project: Project,+ webhookId: string+ ) => Webhook | undefined;+ createProjectWebhook: (project: string, webhook: Webhook) => Promise<Project>;+ updateProjectWebhook: (+ webhook: Webhook,+ updateMask: string[]+ ) => Promise<Project>;+ deleteProjectWebhook: (webhook: Webhook) => Promise<Project>;+ testProjectWebhook: (+ project: Project,+ webhook: Webhook+ ) => Promise<{ error: string }>;+};+export type NotificationSlice = {notify: (notification: NotificationCreate) => void;};@@ -359,6 +496,12 @@ export type AppStoreState = AuthSlice &WorkloadIdentitySlice &IdentityProviderSlice &AccessGrantSlice &+ UserSlice &+ RoleSlice &+ ReleaseSlice &+ RevisionSlice &+ ChangelogSlice &+ ProjectWebhookSlice &NotificationSlice &PreferencesSlice;diff --git a/frontend/src/react/stores/app/user.ts b/frontend/src/react/stores/app/user.tsnew file mode 100644index 0000000000..cc9f8a11b1--- /dev/null+++ b/frontend/src/react/stores/app/user.ts@@ -0,0 +1,288 @@+import { create as createProto } from "@bufbuild/protobuf";+import { createContextValues } from "@connectrpc/connect";+import { uniq } from "lodash-es";+import { userServiceClientConnect } from "@/connect";+import { silentContextKey } from "@/connect/context-key";+import { userNamePrefix } from "@/react/lib/resourceName";+import { extractUserEmail } from "@/store/modules/v1/common";+import {+ allUsersUser,+ isValidProjectName,+ isValidUserName,+ unknownUser,+ userBindingPrefix,+} from "@/types";+import { State } from "@/types/proto-es/v1/common_pb";+import {+ BatchGetUsersRequestSchema,+ CreateUserRequestSchema,+ DeleteUserRequestSchema,+ GetUserRequestSchema,+ ListUsersRequestSchema,+ UndeleteUserRequestSchema,+ UpdateEmailRequestSchema,+ UpdateUserRequestSchema,+} from "@/types/proto-es/v1/user_service_pb";+import { ensureUserFullName } from "@/utils";+import type { AppSliceCreator, UserFilter, UserSlice } from "./types";++const UNKNOWN_PROJECT_NAME_LEGACY = "projects/-";++export const buildUserFilter = (params: UserFilter) => {+ const filter = [];+ const search = params.query?.trim()?.toLowerCase();+ if (search) {+ filter.push(`(name.contains("${search}") || email.contains("${search}"))`);+ }+ if (+ isValidProjectName(params.project) &&+ params.project !== UNKNOWN_PROJECT_NAME_LEGACY+ ) {+ filter.push(`project == "${params.project}"`);+ }+ if (params.state === State.DELETED) {+ filter.push(`state == "${State[params.state]}"`);+ }+ return filter.join(" && ");+};++export const createUserSlice: AppSliceCreator<UserSlice> = (set, get) => {+ const adjustActivatedUserCount = (delta: number) => {+ set((state) => {+ if (!state.serverInfo) {+ return {};+ }+ return {+ serverInfo: {+ ...state.serverInfo,+ activatedUserCount: Math.max(+ 0,+ state.serverInfo.activatedUserCount + delta+ ),+ },+ };+ });+ };++ return {+ usersByName: { [allUsersUser().name]: allUsersUser() },+ userRequests: {},++ listUsers: async (params) => {+ if (!get().hasWorkspacePermission("bb.users.list")) {+ return { users: [], nextPageToken: "" };+ }+ const response = await userServiceClientConnect.listUsers(+ createProto(ListUsersRequestSchema, {+ pageSize: params.pageSize,+ pageToken: params.pageToken,+ filter: buildUserFilter(params.filter ?? {}),+ showDeleted:+ params.showDeleted ?? params.filter?.state === State.DELETED,+ })+ );+ set((state) => ({+ usersByName: {+ ...state.usersByName,+ ...Object.fromEntries(+ response.users.map((user) => [user.name, user])+ ),+ },+ }));+ return { users: response.users, nextPageToken: response.nextPageToken };+ },++ fetchUser: async (name, silent = false) => {+ const validName = ensureUserFullName(name);+ const existing = get().usersByName[validName];+ if (existing) return existing;+ const pending = get().userRequests[validName];+ if (pending) return pending;++ const request = userServiceClientConnect+ .getUser(createProto(GetUserRequestSchema, { name: validName }), {+ contextValues: createContextValues().set(silentContextKey, silent),+ })+ .then((user) => {+ set((state) => {+ const { [validName]: _, ...userRequests } = state.userRequests;+ return {+ usersByName: { ...state.usersByName, [user.name]: user },+ userRequests,+ };+ });+ return user;+ })+ .catch(() => {+ set((state) => {+ const { [validName]: _, ...userRequests } = state.userRequests;+ return { userRequests };+ });+ return undefined;+ });+ set((state) => ({+ userRequests: { ...state.userRequests, [validName]: request },+ }));+ return request;+ },++ batchGetOrFetchUsers: async (names) => {+ const validNames = uniq(names).filter(+ (name) =>+ Boolean(name) &&+ (name.startsWith(userNamePrefix) ||+ name.startsWith(userBindingPrefix))+ );+ const missing = validNames+ .filter((name) => get().getUserByIdentifier(name) === undefined)+ .map((name) => ensureUserFullName(name));++ if (missing.length > 0) {+ try {+ const response = await userServiceClientConnect.batchGetUsers(+ createProto(BatchGetUsersRequestSchema, { names: missing }),+ { contextValues: createContextValues().set(silentContextKey, true) }+ );+ set((state) => ({+ usersByName: {+ ...state.usersByName,+ ...Object.fromEntries(+ response.users.map((user) => [user.name, user])+ ),+ },+ }));+ } catch {+ // Match the legacy store: return cached users plus unknown fallbacks.+ }+ }++ return validNames.map(+ (name) => get().getUserByIdentifier(name) ?? unknownUser(name)+ );+ },++ getOrFetchUserByIdentifier: async ({+ identifier,+ silent = true,+ fallback = true,+ }) => {+ const user = get().getUserByIdentifier(identifier);+ if (user) return user;++ const fullname = ensureUserFullName(identifier);+ if (!isValidUserName(fullname)) {+ return unknownUser();+ }+ const fetched = await get().fetchUser(fullname, silent);+ return fetched ?? unknownUser(fallback ? fullname : "");+ },++ getUserByIdentifier: (identifier) => {+ if (!identifier) return undefined;+ const id = extractUserEmail(identifier);+ if (Number.isNaN(Number(id))) {+ return Object.values(get().usersByName).find(+ (user) => user.email === id+ );+ }+ return get().usersByName[`${userNamePrefix}${id}`];+ },++ createUser: async (user) => {+ const response = await userServiceClientConnect.createUser(+ createProto(CreateUserRequestSchema, { user })+ );+ set((state) => ({+ usersByName: { ...state.usersByName, [response.name]: response },+ }));+ adjustActivatedUserCount(1);+ return response;+ },++ updateUser: async (request) => {+ const name = request.user?.name || "";+ if (!request.allowMissing) {+ const originData = await get().getOrFetchUserByIdentifier({+ identifier: name,+ fallback: false,+ });+ if (!isValidUserName(originData.name)) {+ throw new Error(`user with name ${name} not found`);+ }+ }++ const response = await userServiceClientConnect.updateUser(+ createProto(UpdateUserRequestSchema, {+ user: request.user,+ updateMask: request.updateMask,+ otpCode: request.otpCode,+ regenerateTempMfaSecret: request.regenerateTempMfaSecret,+ regenerateRecoveryCodes: request.regenerateRecoveryCodes,+ allowMissing: request.allowMissing,+ })+ );+ set((state) => ({+ usersByName: { ...state.usersByName, [response.name]: response },+ }));+ return response;+ },++ updateEmail: async (oldEmail, newEmail) => {+ const originData = await get().getOrFetchUserByIdentifier({+ identifier: oldEmail,+ fallback: false,+ });+ if (!isValidUserName(originData.name)) {+ throw new Error(`user with email ${oldEmail} not found`);+ }++ const oldName = originData.name;+ const response = await userServiceClientConnect.updateEmail(+ createProto(UpdateEmailRequestSchema, {+ name: ensureUserFullName(oldEmail),+ email: newEmail,+ })+ );+ set((state) => {+ const usersByName = { ...state.usersByName };+ if (oldName !== response.name) {+ delete usersByName[oldName];+ }+ usersByName[response.name] = response;+ return { usersByName };+ });+ return response;+ },++ archiveUser: async (name) => {+ const validName = ensureUserFullName(name);+ await userServiceClientConnect.deleteUser(+ createProto(DeleteUserRequestSchema, { name: validName })+ );+ set((state) => {+ const cached = state.usersByName[validName];+ if (!cached) return {};+ return {+ usersByName: {+ ...state.usersByName,+ [validName]: { ...cached, state: State.DELETED },+ },+ };+ });+ adjustActivatedUserCount(-1);+ },++ restoreUser: async (name) => {+ const response = await userServiceClientConnect.undeleteUser(+ createProto(UndeleteUserRequestSchema, {+ name: ensureUserFullName(name),+ })+ );+ set((state) => ({+ usersByName: { ...state.usersByName, [response.name]: response },+ }));+ adjustActivatedUserCount(1);+ return response;+ },+ };+};