@tuturuuu/ui 0.26.0 → 0.27.0

package/src/components/ui/custom/workspace-access/workspace-access-page.tsx

@@ -37,9 +37,16 @@ import { WorkspaceAccessMembers } from './workspace-access-members';
 import { WorkspaceAccessPageHeader } from './workspace-access-page-header';
 import { WorkspaceAccessPeopleFilters } from './workspace-access-people-filters';
 import { WorkspaceAccessRoleEditorDialog } from './workspace-access-role-editor-dialog';
+import { listAllWorkspaceAccessRoles } from './workspace-access-role-options';
 import { WorkspaceAccessRoles } from './workspace-access-roles';
 import { WorkspaceAccessTabsToolbar } from './workspace-access-tabs-toolbar';
 
+type InvitationRoleUpdate = {
+  email?: null | string;
+  roleIds: string[];
+  userId?: null | string;
+};
+
 export function WorkspaceAccessPage({
   adapter,
   disableInvite = false,
@@ -57,6 +64,7 @@ export function WorkspaceAccessPage({
   const [inviteAccessPreset, setInviteAccessPreset] = useState<
     'guest' | 'member' | 'pos_operator'
   >('member');
+  const [inviteRoleIds, setInviteRoleIds] = useState<string[]>([]);
   const [confirmDefaultAdminMigration, setConfirmDefaultAdminMigration] =
     useState(false);
   const [inviteDialogOpen, setInviteDialogOpen] = useState(false);
@@ -92,6 +100,7 @@ export function WorkspaceAccessPage({
   const workspaceId = context.workspaceId;
   const canManageMembers = context.canManageMembers;
   const canManageRoles = context.canManageRoles;
+  const canAssignInviteRoles = canManageRoles && mode === 'workspace';
   const canInvite = canManageMembers && !disableInvite;
   const permissionUser = useMemo(
     () =>
@@ -145,6 +154,12 @@ export function WorkspaceAccessPage({
     queryKey: ['workspace-access', workspaceId, 'roles', search],
     staleTime: 30_000,
   });
+  const inviteRolesQuery = useQuery({
+    enabled: inviteDialogOpen && canAssignInviteRoles,
+    queryFn: () => listAllWorkspaceAccessRoles(adapter, workspaceId),
+    queryKey: ['workspace-access', workspaceId, 'invite-roles'],
+    staleTime: 30_000,
+  });
   const memberDefaultQuery = useQuery({
     enabled: canManageRoles,
     queryFn: () => adapter.getDefaultRole(workspaceId, 'MEMBER'),
@@ -166,6 +181,9 @@ export function WorkspaceAccessPage({
       queryClient.invalidateQueries({
         queryKey: ['workspace-access', workspaceId, 'roles'],
       }),
+      queryClient.invalidateQueries({
+        queryKey: ['workspace-access', workspaceId, 'invite-roles'],
+      }),
       queryClient.invalidateQueries({
         queryKey: ['workspace-access', workspaceId, 'defaults'],
       }),
@@ -179,12 +197,17 @@ export function WorkspaceAccessPage({
         confirmDefaultAdminMigration,
         emails: parseInviteEmails(inviteEmails),
         memberType: inviteAccessPreset === 'guest' ? 'GUEST' : 'MEMBER',
+        roleIds:
+          canAssignInviteRoles && inviteAccessPreset === 'member'
+            ? inviteRoleIds
+            : [],
       }),
     onError: (error) =>
       toast.error(error instanceof Error ? error.message : t('common.error')),
     onSuccess: async (result) => {
       setInviteEmails('');
       setInviteAccessPreset('member');
+      setInviteRoleIds([]);
       setConfirmDefaultAdminMigration(false);
       setInviteDialogOpen(false);
       toast.success(result.message ?? t('ws-members.invitation-sent'));
@@ -247,6 +270,66 @@ export function WorkspaceAccessPage({
       await invalidateAccessData();
     },
   });
+  const invitationRoleMutation = useMutation({
+    mutationFn: (payload: InvitationRoleUpdate) => {
+      if (!adapter.updateInvitationRole) {
+        throw new Error(t('common.error'));
+      }
+      return adapter.updateInvitationRole(workspaceId, payload);
+    },
+    onMutate: async (payload) => {
+      const queryKey = ['workspace-access', workspaceId, 'members'] as const;
+      await queryClient.cancelQueries({ queryKey });
+      const previousMembers =
+        queryClient.getQueryData<InternalApiEnhancedWorkspaceMember[]>(
+          queryKey
+        );
+      const roleById = new Map(
+        (inviteRolesQuery.data?.data ?? rolesQuery.data?.data ?? []).map(
+          (role) => [role.id, role]
+        )
+      );
+      const nextRoles = payload.roleIds.flatMap((roleId) => {
+        const role = roleById.get(roleId);
+        return role ? [{ id: role.id, name: role.name, permissions: [] }] : [];
+      });
+      const normalizedEmail = payload.email?.trim().toLowerCase() ?? null;
+
+      queryClient.setQueryData<InternalApiEnhancedWorkspaceMember[]>(
+        queryKey,
+        (members = []) =>
+          members.map((member) => {
+            const matchesUser = Boolean(
+              payload.userId && member.id === payload.userId
+            );
+            const matchesEmail = Boolean(
+              normalizedEmail &&
+                member.email?.trim().toLowerCase() === normalizedEmail
+            );
+            if (!member.pending || (!matchesUser && !matchesEmail)) {
+              return member;
+            }
+
+            return {
+              ...member,
+              roles: nextRoles,
+            };
+          })
+      );
+
+      return { previousMembers, queryKey };
+    },
+    onError: (error, _payload, context) => {
+      if (context?.previousMembers) {
+        queryClient.setQueryData(context.queryKey, context.previousMembers);
+      }
+      toast.error(error instanceof Error ? error.message : t('common.error'));
+    },
+    onSettled: invalidateAccessData,
+    onSuccess: () => {
+      toast.success(t('ws-members.invitation_role_updated'));
+    },
+  });
   const deleteRoleMutation = useMutation({
     mutationFn: (roleId: string) => adapter.deleteRole(workspaceId, roleId),
     onError: (error) =>
@@ -394,11 +477,15 @@ export function WorkspaceAccessPage({
             canEditProfiles={Boolean(adapter.updateMemberProfile)}
             canManageMembers={canManageMembers}
             canManageRoles={canManageRoles}
+            canUpdateInvitationRoles={
+              canManageRoles && Boolean(adapter.updateInvitationRole)
+            }
             defaultAdminEnabled={defaultAdminEnabled}
             isLoading={membersQuery.isPending}
             isMutating={
               removeMemberMutation.isPending ||
               roleMembershipMutation.isPending ||
+              invitationRoleMutation.isPending ||
               updateMemberProfileMutation.isPending
             }
             labels={labels}
@@ -411,7 +498,10 @@ export function WorkspaceAccessPage({
             onRemoveRole={(payload) =>
               roleMembershipMutation.mutate({ ...payload, action: 'remove' })
             }
-            roles={roles}
+            onUpdateInvitationRole={(payload) =>
+              invitationRoleMutation.mutate(payload)
+            }
+            roles={inviteRolesQuery.data?.data ?? roles}
             searchTerm={search}
             status={status}
           />
@@ -475,23 +565,32 @@ export function WorkspaceAccessPage({
 
       <WorkspaceAccessInviteDialog
         accessPreset={inviteAccessPreset}
-        canManageRoles={canManageRoles}
+        canManageRoles={canAssignInviteRoles}
         confirmDefaultAdminMigration={confirmDefaultAdminMigration}
         defaultAdminEnabled={defaultAdminEnabled}
         emails={inviteEmails}
         isSubmitting={inviteMutation.isPending}
         joinedMemberCount={joinedCount}
+        noRoleLabel={t('ws-members.no_role_assigned')}
         onAccessPresetChange={(value) => {
           setInviteAccessPreset(value);
-          if (value !== 'pos_operator') {
+          if (value === 'member') {
             setConfirmDefaultAdminMigration(false);
+          } else {
+            setInviteRoleIds([]);
+            if (value === 'guest') {
+              setConfirmDefaultAdminMigration(false);
+            }
           }
         }}
         onConfirmDefaultAdminMigrationChange={setConfirmDefaultAdminMigration}
         onEmailsChange={setInviteEmails}
         onOpenChange={setInviteDialogOpen}
+        onRoleIdsChange={setInviteRoleIds}
         onSubmit={() => inviteMutation.mutate()}
         open={inviteDialogOpen}
+        roleIds={inviteRoleIds}
+        roles={inviteRolesQuery.data?.data ?? []}
       />
 
       {profileMember ? (

package/src/components/ui/custom/workspace-access/workspace-access-role-options.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { WorkspaceAccessAdapter, WorkspaceAccessRole } from './types';
+import { listAllWorkspaceAccessRoles } from './workspace-access-role-options';
+
+function createRoles(start: number, count: number): WorkspaceAccessRole[] {
+  return Array.from({ length: count }, (_, index) => ({
+    id: `role-${start + index}`,
+    name: `Role ${start + index}`,
+    permissions: [],
+  }));
+}
+
+describe('listAllWorkspaceAccessRoles', () => {
+  it('paginates beyond the first 100 assignable roles', async () => {
+    const listRoleOptions = vi
+      .fn()
+      .mockResolvedValueOnce({ count: 125, data: createRoles(0, 100) })
+      .mockResolvedValueOnce({ count: 125, data: createRoles(100, 25) });
+
+    const result = await listAllWorkspaceAccessRoles(
+      { listRoleOptions } as unknown as WorkspaceAccessAdapter,
+      'workspace-1'
+    );
+
+    expect(result.data).toHaveLength(125);
+    expect(listRoleOptions).toHaveBeenNthCalledWith(1, 'workspace-1', {
+      page: '1',
+      pageSize: '100',
+    });
+    expect(listRoleOptions).toHaveBeenNthCalledWith(2, 'workspace-1', {
+      page: '2',
+      pageSize: '100',
+    });
+  });
+});

package/src/components/ui/custom/workspace-access/workspace-access-role-options.ts

@@ -0,0 +1,21 @@
+import type { WorkspaceAccessAdapter, WorkspaceAccessRole } from './types';
+
+export async function listAllWorkspaceAccessRoles(
+  adapter: WorkspaceAccessAdapter,
+  workspaceId: string
+) {
+  const pageSize = 100;
+  const roles: WorkspaceAccessRole[] = [];
+
+  for (let page = 1; ; page += 1) {
+    const result = await adapter.listRoleOptions(workspaceId, {
+      page: String(page),
+      pageSize: String(pageSize),
+    });
+    roles.push(...result.data.map((role) => ({ ...role, permissions: [] })));
+
+    if (roles.length >= result.count || result.data.length < pageSize) {
+      return { count: result.count, data: roles };
+    }
+  }
+}

package/src/components/ui/custom/workspace-select-invitations.tsx

@@ -31,8 +31,9 @@ export function useWorkspaceInvitations({
     queryKey: ['workspace-invitations', ...(cacheScope ? [cacheScope] : [])],
     queryFn: async () => (await listWorkspaceInvitations()).invitations,
     enabled,
+    gcTime: 30 * 60_000,
     retry: 1,
-    staleTime: 30_000,
+    staleTime: 5 * 60_000,
   });
   const invitations = query.data ?? [];
   const mutation = useMutation({

package/src/components/ui/legacy/polls/poll-display.test.tsx

@@ -0,0 +1,118 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { PlanDetailsPollContent } from './poll-display';
+
+const mocks = vi.hoisted(() => ({
+  addPollOption: vi.fn(),
+  createPoll: vi.fn(),
+  deletePoll: vi.fn(),
+  deletePollOption: vi.fn(),
+  refresh: vi.fn(),
+  submitVote: vi.fn(),
+  toast: vi.fn(),
+  toggleWherePoll: vi.fn(),
+  useTimeBlocking: vi.fn(),
+}));
+
+vi.mock('@tuturuuu/apis/meet/actions', () => ({
+  addPollOption: (...args: unknown[]) => mocks.addPollOption(...args),
+  createPoll: (...args: unknown[]) => mocks.createPoll(...args),
+  deletePoll: (...args: unknown[]) => mocks.deletePoll(...args),
+  deletePollOption: (...args: unknown[]) => mocks.deletePollOption(...args),
+  submitVote: (...args: unknown[]) => mocks.submitVote(...args),
+  toggleWherePoll: (...args: unknown[]) => mocks.toggleWherePoll(...args),
+}));
+
+vi.mock('@tuturuuu/ui/hooks/time-blocking-provider', () => ({
+  useTimeBlocking: () => mocks.useTimeBlocking(),
+}));
+
+vi.mock('@tuturuuu/ui/hooks/use-toast', () => ({
+  toast: (...args: unknown[]) => mocks.toast(...args),
+}));
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({ refresh: mocks.refresh }),
+}));
+
+vi.mock('next-intl', () => ({
+  useTranslations: () => (key: string) => key,
+}));
+
+vi.mock('./where-tu-meet', () => ({
+  DefaultWherePollContent: ({
+    onAddOption,
+    onVote,
+  }: {
+    onAddOption: (pollId: string, value: string) => Promise<unknown>;
+    onVote: (pollId: string, optionIds: string[]) => Promise<void>;
+  }) => (
+    <div>
+      <button type="button" onClick={() => onAddOption('poll-1', 'Cafe')}>
+        add guest option
+      </button>
+      <button type="button" onClick={() => onVote('poll-1', ['option-1'])}>
+        submit guest vote
+      </button>
+    </div>
+  ),
+}));
+
+describe('PlanDetailsPollContent guest authorization', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.useTimeBlocking.mockReturnValue({
+      user: {
+        display_name: 'Guest',
+        id: 'guest-1',
+        is_guest: true,
+        password_hash: 'plan-bound-credential',
+      },
+    });
+    mocks.addPollOption.mockResolvedValue({
+      data: {
+        option: {
+          created_at: '2026-08-10T00:00:00.000Z',
+          guestVotes: [],
+          id: 'option-1',
+          poll_id: 'poll-1',
+          totalVotes: 0,
+          userVotes: [],
+          value: 'Cafe',
+        },
+      },
+    });
+    mocks.submitVote.mockResolvedValue({ data: { success: true } });
+  });
+
+  it('forwards the selected guest credential to option and vote actions', async () => {
+    render(
+      <PlanDetailsPollContent
+        plan={{ id: 'plan-1', is_confirmed: false, where_to_meet: true }}
+        isCreator={false}
+        platformUser={null}
+        polls={null}
+      />
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'add guest option' }));
+    fireEvent.click(screen.getByRole('button', { name: 'submit guest vote' }));
+
+    await waitFor(() => {
+      expect(mocks.addPollOption).toHaveBeenCalledWith('plan-1', {
+        guestId: 'guest-1',
+        guestPasswordHash: 'plan-bound-credential',
+        pollId: 'poll-1',
+        userType: 'GUEST',
+        value: 'Cafe',
+      });
+      expect(mocks.submitVote).toHaveBeenCalledWith('plan-1', {
+        guestId: 'guest-1',
+        guestPasswordHash: 'plan-bound-credential',
+        optionIds: ['option-1'],
+        pollId: 'poll-1',
+        userType: 'GUEST',
+      });
+    });
+  });
+});

package/src/components/ui/legacy/polls/poll-display.tsx

@@ -94,6 +94,10 @@ export function PlanDetailsPollContent({
       optionIds,
       userType: userType as 'PLATFORM' | 'GUEST',
       guestId: userType === 'GUEST' ? (user?.id ?? undefined) : undefined,
+      guestPasswordHash:
+        userType === 'GUEST' && guestUser?.is_guest
+          ? guestUser.password_hash
+          : undefined,
     });
     if (result.error) {
       toast({
@@ -111,6 +115,10 @@ export function PlanDetailsPollContent({
       value,
       userType: userType as 'PLATFORM' | 'GUEST',
       guestId: userType === 'GUEST' ? (user?.id ?? undefined) : undefined,
+      guestPasswordHash:
+        userType === 'GUEST' && guestUser?.is_guest
+          ? guestUser.password_hash
+          : undefined,
     });
     if (result.error) {
       toast({

package/src/hooks/__tests__/use-notifications-subscription.test.tsx

@@ -9,6 +9,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   __resetNotificationSubscriptionRegistryForTests,
   UNREAD_COUNT_FALLBACK_INTERVAL_MS,
+  UNREAD_COUNT_STALE_TIME_MS,
   useInfiniteNotifications,
   useNotificationSubscription,
   useUnreadCount,
@@ -16,6 +17,7 @@ import {
 
 type RealtimePayload = {
   new?: {
+    read_at?: string | null;
     data?: {
       action_taken?: boolean;
     };
@@ -126,8 +128,15 @@ describe('useNotificationSubscription', () => {
       wrapper: createWrapper(queryClient),
     });
 
+    const queryOptions = queryClient.getQueryCache().find({
+      queryKey: ['notifications', 'unread-count', 'all'],
+    })?.options as { refetchInterval?: number; staleTime?: number } | undefined;
+
     expect(fetchMock).not.toHaveBeenCalled();
-    expect(UNREAD_COUNT_FALLBACK_INTERVAL_MS).toBe(5 * 60 * 1000);
+    expect(queryOptions?.staleTime).toBe(UNREAD_COUNT_STALE_TIME_MS);
+    expect(queryOptions?.refetchInterval).toBe(
+      UNREAD_COUNT_FALLBACK_INTERVAL_MS
+    );
   });
 
   it('shares one realtime channel across multiple consumers for the same user', async () => {
@@ -157,6 +166,30 @@ describe('useNotificationSubscription', () => {
     expect(removeChannelMock).toHaveBeenCalledTimes(1);
   });
 
+  it('invalidates unread counts for read-state-only realtime updates', async () => {
+    const queryClient = createQueryClient();
+    const invalidate = vi.spyOn(queryClient, 'invalidateQueries');
+    const subscription = renderHook(
+      () => useNotificationSubscription(null, 'user-1'),
+      { wrapper: createWrapper(queryClient) }
+    );
+
+    await waitFor(() => {
+      expect(postgresCallbacks).toHaveLength(3);
+    });
+
+    postgresCallbacks[1]?.({ new: { read_at: new Date().toISOString() } });
+
+    expect(invalidate).toHaveBeenCalledWith({
+      queryKey: ['notifications'],
+    });
+    expect(invalidate).toHaveBeenCalledWith({
+      queryKey: ['notifications', 'unread-count'],
+    });
+
+    subscription.unmount();
+  });
+
   it('invalidates every mounted query client from the shared subscription', async () => {
     const firstQueryClient = createQueryClient();
     const secondQueryClient = createQueryClient();

package/src/hooks/use-board-actions.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { getBoardActionError } from './use-board-actions';
+
+describe('getBoardActionError', () => {
+  it('uses the API error field returned by board lifecycle routes', async () => {
+    const response = Response.json(
+      { error: "You don't have access to this workspace" },
+      { status: 403 }
+    );
+
+    await expect(getBoardActionError(response, 'fallback')).resolves.toBe(
+      "You don't have access to this workspace"
+    );
+  });
+
+  it('falls back when the response is not JSON', async () => {
+    const response = new Response('Bad gateway', { status: 502 });
+
+    await expect(
+      getBoardActionError(response, 'Board action failed')
+    ).resolves.toBe('Board action failed');
+  });
+});

package/src/hooks/use-board-actions.ts

@@ -2,6 +2,20 @@ import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { toast } from '@tuturuuu/ui/sonner';
 import { getTaskApiUrl } from '../lib/tasks-app-url';
 
+export async function getBoardActionError(
+  response: Response,
+  fallback: string
+) {
+  const errorData = (await response.json().catch(() => null)) as {
+    error?: unknown;
+    message?: unknown;
+  } | null;
+
+  if (typeof errorData?.error === 'string') return errorData.error;
+  if (typeof errorData?.message === 'string') return errorData.message;
+  return fallback;
+}
+
 async function boardAction(
   wsId: string,
   boardId: string,
@@ -21,8 +35,7 @@ async function boardAction(
   );
 
   if (!response.ok) {
-    const errorData = await response.json();
-    throw new Error(errorData.message || 'Board action failed');
+    throw new Error(await getBoardActionError(response, 'Board action failed'));
   }
 
   return response.json();
@@ -45,8 +58,9 @@ async function archiveAction(
   );
 
   if (!response.ok) {
-    const errorData = await response.json();
-    throw new Error(errorData.message || 'Archive action failed');
+    throw new Error(
+      await getBoardActionError(response, 'Archive action failed')
+    );
   }
 
   return response.json();
@@ -59,19 +73,28 @@ interface BoardActionOptions {
 export function useBoardActions(wsId: string) {
   const queryClient = useQueryClient();
 
+  const invalidateBoardQueries = (boardId: string) => {
+    void queryClient.invalidateQueries({ queryKey: ['boards', wsId] });
+    void queryClient.invalidateQueries({
+      queryKey: ['accessible-task-boards'],
+    });
+    void queryClient.invalidateQueries({
+      queryKey: ['task-board', wsId, boardId],
+    });
+    void queryClient.invalidateQueries({
+      queryKey: ['task-board-settings', wsId, boardId],
+    });
+  };
+
   const softDeleteMutation = useMutation<
     any,
     Error,
     { boardId: string; options?: BoardActionOptions }
   >({
     mutationFn: ({ boardId }) => boardAction(wsId, boardId, 'PUT'),
-    onSuccess: (_, { options }) => {
+    onSuccess: (_, { boardId, options }) => {
       toast.success('Board moved to trash successfully');
-      // Invalidate all queries that start with ['boards', wsId]
-      // Using exact: false (default) to match all queries with this prefix
-      queryClient.invalidateQueries({
-        queryKey: ['boards', wsId],
-      });
+      invalidateBoardQueries(boardId);
       options?.onSuccess?.();
     },
     onError: (error: Error) => {
@@ -87,12 +110,9 @@ export function useBoardActions(wsId: string) {
     { boardId: string; options?: BoardActionOptions }
   >({
     mutationFn: ({ boardId }) => boardAction(wsId, boardId, 'DELETE'),
-    onSuccess: (_, { options }) => {
+    onSuccess: (_, { boardId, options }) => {
       toast.success('Board permanently deleted successfully');
-      // Invalidate all queries that start with ['boards', wsId]
-      queryClient.invalidateQueries({
-        queryKey: ['boards', wsId],
-      });
+      invalidateBoardQueries(boardId);
       options?.onSuccess?.();
     },
     onError: (error: Error) => {
@@ -109,12 +129,9 @@ export function useBoardActions(wsId: string) {
   >({
     mutationFn: ({ boardId }) =>
       boardAction(wsId, boardId, 'PATCH', { restore: true }),
-    onSuccess: (_, { options }) => {
+    onSuccess: (_, { boardId, options }) => {
       toast.success('Board restored successfully');
-      // Invalidate all queries that start with ['boards', wsId]
-      queryClient.invalidateQueries({
-        queryKey: ['boards', wsId],
-      });
+      invalidateBoardQueries(boardId);
       options?.onSuccess?.();
     },
     onError: (error: Error) => {
@@ -130,12 +147,9 @@ export function useBoardActions(wsId: string) {
     { boardId: string; options?: BoardActionOptions }
   >({
     mutationFn: ({ boardId }) => archiveAction(wsId, boardId, 'POST'),
-    onSuccess: (_, { options }) => {
+    onSuccess: (_, { boardId, options }) => {
       toast.success('Board archived successfully');
-      // Invalidate all queries that start with ['boards', wsId]
-      queryClient.invalidateQueries({
-        queryKey: ['boards', wsId],
-      });
+      invalidateBoardQueries(boardId);
       options?.onSuccess?.();
     },
     onError: (error: Error) => {
@@ -151,12 +165,9 @@ export function useBoardActions(wsId: string) {
     { boardId: string; options?: BoardActionOptions }
   >({
     mutationFn: ({ boardId }) => archiveAction(wsId, boardId, 'DELETE'),
-    onSuccess: (_, { options }) => {
+    onSuccess: (_, { boardId, options }) => {
       toast.success('Board unarchived successfully');
-      // Invalidate all queries that start with ['boards', wsId]
-      queryClient.invalidateQueries({
-        queryKey: ['boards', wsId],
-      });
+      invalidateBoardQueries(boardId);
       options?.onSuccess?.();
     },
     onError: (error: Error) => {
@@ -191,12 +202,9 @@ export function useBoardActions(wsId: string) {
         }
         return res.json();
       }),
-    onSuccess: (_, { options }) => {
+    onSuccess: (_, { boardId, options }) => {
       toast.success('Board duplicated successfully');
-      // Invalidate all queries that start with ['boards', wsId]
-      queryClient.invalidateQueries({
-        queryKey: ['boards', wsId],
-      });
+      invalidateBoardQueries(boardId);
       options?.onSuccess?.();
     },
     onError: (error: Error) => {
@@ -219,5 +227,10 @@ export function useBoardActions(wsId: string) {
       unarchiveMutation.mutate({ boardId, options }),
     duplicateBoard: (boardId: string, options?: BoardActionOptions) =>
       duplicateMutation.mutate({ boardId, options }),
+    isArchiving: archiveMutation.isPending,
+    isDeleting: softDeleteMutation.isPending,
+    isPermanentlyDeleting: permanentDeleteMutation.isPending,
+    isRestoring: restoreMutation.isPending,
+    isUnarchiving: unarchiveMutation.isPending,
   };
 }