@tuturuuu/ui 0.26.1 → 0.27.0

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,
   };
 }

package/src/hooks/use-calendar-sync.tsx

@@ -240,7 +240,7 @@ export const CalendarSyncProvider = ({
     queryKey: ['workspace-calendars', wsId],
     enabled: !hasExternalEvents && !!wsId,
     queryFn: () => listWorkspaceCalendars(wsId),
-    staleTime: 30_000,
+    staleTime: 5 * 60_000,
   });
   const enabledWorkspaceCalendarIds = useMemo(
     () =>
@@ -438,12 +438,11 @@ export const CalendarSyncProvider = ({
     [isVisibleInCurrentRange]
   );
 
-  // Fetch database events with caching
   const { data: fetchedData, isLoading: isDatabaseLoading } = useQuery({
     queryKey: ['databaseCalendarEvents', wsId, activeCacheKey],
     enabled: !hasExternalEvents && !!wsId && dates.length > 0,
-    staleTime: 30000, // Consider data fresh for 30 seconds
-    gcTime: 5 * 60 * 1000, // Keep in cache for 5 minutes
+    staleTime: 2 * 60_000,
+    gcTime: 30 * 60_000,
     queryFn: async () => {
       if (!activeCacheKey) return null;
 
@@ -512,10 +511,11 @@ export const CalendarSyncProvider = ({
           lastSyncTime: new Date(),
         });
 
-        return cachedData?.dbEvents ?? [];
+        throw err instanceof Error ? err : new Error(errorMessage);
       }
     },
-    refetchInterval: 60000, // Reduced from 30s to 60s to lower load
+    refetchInterval: 5 * 60_000,
+    refetchIntervalInBackground: false,
   });
 
   // Legacy direct Google fetch/reconcile is disabled. Provider inbound sync is
@@ -523,18 +523,17 @@ export const CalendarSyncProvider = ({
   const { isLoading: isGoogleLoading } = useQuery({
     queryKey: ['googleCalendarEvents', wsId, activeCacheKey],
     enabled: false,
-    staleTime: 30000, // Consider data fresh for 30 seconds
-    gcTime: 5 * 60 * 1000, // Keep in cache for 5 minutes
+    staleTime: 2 * 60_000,
+    gcTime: 30 * 60_000,
     queryFn: async () => null,
-    refetchInterval: 60000, // Reduced from 30s to 60s to lower load
   });
 
   // Fetch habit calendar events to identify which events are habits
   const { data: habitEventData } = useQuery({
     queryKey: ['habitCalendarEvents', wsId, activeCacheKey],
     enabled: !hasExternalEvents && !!wsId && dates.length > 0,
-    staleTime: 60000, // Consider data fresh for 1 minute
-    gcTime: 5 * 60 * 1000, // Keep in cache for 5 minutes
+    staleTime: 2 * 60_000,
+    gcTime: 30 * 60_000,
     queryFn: async () => {
       const startDate = dayjs(dates[0]).startOf('day');
       const endDate = dayjs(dates[dates.length - 1])
@@ -571,7 +570,8 @@ export const CalendarSyncProvider = ({
         };
       }
     },
-    refetchInterval: 60000, // Refetch every minute
+    refetchInterval: 5 * 60_000,
+    refetchIntervalInBackground: false,
   });
 
   // Helper to check if dates have actually changed

package/src/hooks/use-notifications.ts

@@ -91,7 +91,8 @@ interface NotificationSubscriptionEntry {
   supabase: SupabaseClient;
 }
 
-export const UNREAD_COUNT_FALLBACK_INTERVAL_MS = 5 * 60 * 1000;
+export const UNREAD_COUNT_STALE_TIME_MS = 5 * 60 * 1000;
+export const UNREAD_COUNT_FALLBACK_INTERVAL_MS = 15 * 60 * 1000;
 
 const notificationSubscriptionRegistry = new Map<
   string,
@@ -164,12 +165,7 @@ function createNotificationSubscriptionEntry(
         table: 'notifications',
         filter: `user_id=eq.${userId}`,
       },
-      (payload) => {
-        const newRecord = payload.new as Notification;
-        if (newRecord?.data?.action_taken) {
-          invalidateQueries();
-        }
-      }
+      invalidateQueries
     )
     .on(
       'postgres_changes',
@@ -348,7 +344,7 @@ export function useUnreadCount(
       return data.count as number;
     },
     enabled: options?.enabled ?? true,
-    staleTime: 60_000,
+    staleTime: UNREAD_COUNT_STALE_TIME_MS,
     // Realtime invalidation is the primary update path. Keep a low-frequency
     // refresh as a safety net for disconnected or suspended browser sessions.
     refetchInterval: UNREAD_COUNT_FALLBACK_INTERVAL_MS,