@tuturuuu/ui 0.8.0 → 0.10.0

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/use-task-data.ts

@@ -1,5 +1,8 @@
 import { useQuery } from '@tanstack/react-query';
-import { listWorkspaceTaskProjects } from '@tuturuuu/internal-api/tasks';
+import {
+  listWorkspaceTaskBoardViewableMembers,
+  listWorkspaceTaskProjects,
+} from '@tuturuuu/internal-api/tasks';
 import { createClient } from '@tuturuuu/supabase/next/client';
 import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
 import {
@@ -89,10 +92,19 @@ interface UseTaskDataProps {
   isOpen: boolean;
   propAvailableLists?: TaskList[];
   taskSearchQuery?: string;
+  canUseBoardAssignees?: boolean;
+  assigneeMemberSource?: 'workspace' | 'board' | 'workspace-and-board';
   /** Pre-loaded data for shared task context - bypasses internal fetches when provided */
   sharedContext?: SharedTaskContext;
 }
 
+type TaskDialogWorkspaceMember = {
+  id: string;
+  user_id: string;
+  display_name: string;
+  avatar_url?: string | null;
+};
+
 // UUID validation regex
 const UUID_REGEX =
   /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -107,6 +119,8 @@ export function useTaskData({
   isOpen,
   propAvailableLists,
   taskSearchQuery = '',
+  canUseBoardAssignees,
+  assigneeMemberSource,
   sharedContext,
 }: UseTaskDataProps) {
   // If sharedContext is provided, use pre-loaded data and skip fetches
@@ -174,17 +188,19 @@ export function useTaskData({
   );
   const workspaceLabels =
     sharedContext?.workspaceLabels || fetchedWorkspaceLabels;
+  const effectiveAssigneeMemberSource = assigneeMemberSource ?? 'workspace';
+  const shouldLoadWorkspaceMembers =
+    canUseBoardAssignees !== false && effectiveAssigneeMemberSource !== 'board';
+  const shouldLoadBoardViewableMembers =
+    canUseBoardAssignees !== false &&
+    effectiveAssigneeMemberSource !== 'workspace' &&
+    !!boardId;
 
   // Workspace members
   const { data: fetchedWorkspaceMembers = [] } = useQuery<
-    Array<{
-      id: string;
-      user_id: string;
-      display_name: string;
-      avatar_url?: string | null;
-    }>
+    TaskDialogWorkspaceMember[]
   >({
-    queryKey: ['workspace-members', realWorkspaceId],
+    queryKey: ['workspace-members', realWorkspaceId, 'workspace'],
     queryFn: async () => {
       if (!realWorkspaceId || !isValidWsId) return [];
 
@@ -234,11 +250,64 @@ export function useTaskData({
         (a.display_name || '').localeCompare(b.display_name || '')
       );
     },
-    enabled: !!realWorkspaceId && isOpen && isValidWsId && !hasSharedContext,
+    enabled:
+      !!realWorkspaceId &&
+      isOpen &&
+      isValidWsId &&
+      !hasSharedContext &&
+      shouldLoadWorkspaceMembers,
+    staleTime: 5 * 60 * 1000, // 5 minutes
+  });
+  const { data: fetchedBoardViewableMembers = [] } = useQuery<
+    TaskDialogWorkspaceMember[]
+  >({
+    queryKey: ['task-board-viewable-members', realWorkspaceId, boardId],
+    queryFn: async () => {
+      if (!realWorkspaceId || !isValidWsId || !boardId) return [];
+
+      const payload = await listWorkspaceTaskBoardViewableMembers(
+        realWorkspaceId,
+        boardId
+      );
+      const members = Array.isArray(payload?.members) ? payload.members : [];
+
+      return members
+        .map((member) => ({
+          id: member.user_id,
+          user_id: member.user_id,
+          display_name: member.display_name || member.email || member.user_id,
+          avatar_url: member.avatar_url,
+        }))
+        .sort((a, b) =>
+          (a.display_name || '').localeCompare(b.display_name || '')
+        );
+    },
+    enabled:
+      !!realWorkspaceId &&
+      isOpen &&
+      isValidWsId &&
+      !hasSharedContext &&
+      shouldLoadBoardViewableMembers,
     staleTime: 5 * 60 * 1000, // 5 minutes
   });
+  const mergedFetchedWorkspaceMembers = useMemo(() => {
+    const seen = new Set<string>();
+    const merged: TaskDialogWorkspaceMember[] = [];
+
+    for (const member of [
+      ...fetchedWorkspaceMembers,
+      ...fetchedBoardViewableMembers,
+    ]) {
+      const memberId = member.user_id || member.id;
+      if (!memberId || seen.has(memberId)) continue;
+      seen.add(memberId);
+      merged.push(member);
+    }
+
+    return merged;
+  }, [fetchedBoardViewableMembers, fetchedWorkspaceMembers]);
   const workspaceMembers =
-    sharedContext?.workspaceMembers || fetchedWorkspaceMembers;
+    sharedContext?.workspaceMembers || mergedFetchedWorkspaceMembers;
 
   // Task projects
   const { data: fetchedTaskProjects = [] } = useQuery({

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/use-task-mutations.ts

@@ -6,13 +6,17 @@ import {
 import type { TaskPriority } from '@tuturuuu/types/primitives/Priority';
 import type { CalendarHoursType } from '@tuturuuu/types/primitives/Task';
 import { useToast } from '@tuturuuu/ui/hooks/use-toast';
-import { invalidateTaskCaches } from '@tuturuuu/utils/task-helper';
 import { useCallback, useState } from 'react';
 import {
   type BoardBroadcastFn,
   getActiveBroadcast,
   useBoardBroadcast,
 } from '../../board-broadcast-context';
+import {
+  patchTaskInVisibleCaches,
+  restoreVisibleTaskCaches,
+  snapshotVisibleTaskCaches,
+} from '../../task-cache-patches';
 import { updateWorkspaceTask } from './task-api';
 
 export interface SchedulingSettings {
@@ -109,17 +113,17 @@ export function useTaskMutations({
         return;
       }
       setEstimationSaving(true);
+      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
+        taskId,
+      ]);
 
       // Optimistic update - prevents flicker by updating cache immediately
-      queryClient.setQueryData(
-        ['tasks', boardId],
-        (oldTasks: any[] | undefined) => {
-          if (!oldTasks) return oldTasks;
-          return oldTasks.map((task) =>
-            task.id === taskId ? { ...task, estimation_points: points } : task
-          );
-        }
-      );
+      patchTaskInVisibleCaches({
+        queryClient,
+        boardId,
+        taskId,
+        updater: (task) => ({ ...task, estimation_points: points }),
+      });
 
       try {
         const { task } = await updateWorkspaceTask(wsId, taskId, {
@@ -135,7 +139,7 @@ export function useTaskMutations({
       } catch (e: any) {
         console.error('Failed updating estimation', e);
         // Revert optimistic update on error
-        await invalidateTaskCaches(queryClient, boardId);
+        restoreVisibleTaskCaches(queryClient, cacheSnapshot);
         toast({
           title: 'Failed to update estimation',
           description: e.message || 'Please try again',
@@ -166,17 +170,17 @@ export function useTaskMutations({
       if (isCreateMode || !taskId || taskId === 'new') {
         return;
       }
+      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
+        taskId,
+      ]);
 
       // Optimistic update - prevents flicker
-      queryClient.setQueryData(
-        ['tasks', boardId],
-        (oldTasks: any[] | undefined) => {
-          if (!oldTasks) return oldTasks;
-          return oldTasks.map((task) =>
-            task.id === taskId ? { ...task, priority: newPriority } : task
-          );
-        }
-      );
+      patchTaskInVisibleCaches({
+        queryClient,
+        boardId,
+        taskId,
+        updater: (task) => ({ ...task, priority: newPriority }),
+      });
 
       try {
         const { task } = await updateWorkspaceTask(wsId, taskId, {
@@ -192,7 +196,7 @@ export function useTaskMutations({
       } catch (e: any) {
         console.error('Failed updating priority', e);
         // Revert optimistic update on error
-        await invalidateTaskCaches(queryClient, boardId);
+        restoreVisibleTaskCaches(queryClient, cacheSnapshot);
         toast({
           title: 'Failed to update priority',
           description: e.message || 'Please try again',
@@ -222,17 +226,17 @@ export function useTaskMutations({
       }
 
       const dateString = newDate ? newDate.toISOString() : null;
+      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
+        taskId,
+      ]);
 
       // Optimistic update - prevents flicker
-      queryClient.setQueryData(
-        ['tasks', boardId],
-        (oldTasks: any[] | undefined) => {
-          if (!oldTasks) return oldTasks;
-          return oldTasks.map((task) =>
-            task.id === taskId ? { ...task, start_date: dateString } : task
-          );
-        }
-      );
+      patchTaskInVisibleCaches({
+        queryClient,
+        boardId,
+        taskId,
+        updater: (task) => ({ ...task, start_date: dateString ?? undefined }),
+      });
 
       try {
         const { task } = await updateWorkspaceTask(wsId, taskId, {
@@ -248,7 +252,7 @@ export function useTaskMutations({
       } catch (e: any) {
         console.error('Failed updating start date', e);
         // Revert optimistic update on error
-        await invalidateTaskCaches(queryClient, boardId);
+        restoreVisibleTaskCaches(queryClient, cacheSnapshot);
         toast({
           title: 'Failed to update start date',
           description: e.message || 'Please try again',
@@ -277,17 +281,17 @@ export function useTaskMutations({
       }
 
       const dateString = newDate ? newDate.toISOString() : null;
+      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
+        taskId,
+      ]);
 
       // Optimistic update - prevents flicker
-      queryClient.setQueryData(
-        ['tasks', boardId],
-        (oldTasks: any[] | undefined) => {
-          if (!oldTasks) return oldTasks;
-          return oldTasks.map((task) =>
-            task.id === taskId ? { ...task, end_date: dateString } : task
-          );
-        }
-      );
+      patchTaskInVisibleCaches({
+        queryClient,
+        boardId,
+        taskId,
+        updater: (task) => ({ ...task, end_date: dateString }),
+      });
 
       try {
         const { task } = await updateWorkspaceTask(wsId, taskId, {
@@ -303,7 +307,7 @@ export function useTaskMutations({
       } catch (e: any) {
         console.error('Failed updating end date', e);
         // Revert optimistic update on error
-        await invalidateTaskCaches(queryClient, boardId);
+        restoreVisibleTaskCaches(queryClient, cacheSnapshot);
         toast({
           title: 'Failed to update end date',
           description: e.message || 'Please try again',
@@ -331,38 +335,33 @@ export function useTaskMutations({
       if (isCreateMode || !taskId || taskId === 'new') {
         return;
       }
+      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
+        taskId,
+      ]);
 
       // Optimistic update - prevents flicker
-      queryClient.setQueryData(
-        ['tasks', boardId],
-        (oldTasks: any[] | undefined) => {
-          if (!oldTasks) return oldTasks;
-          return oldTasks.map((task) =>
-            task.id === taskId ? { ...task, list_id: newListId } : task
-          );
-        }
-      );
+      patchTaskInVisibleCaches({
+        queryClient,
+        boardId,
+        taskId,
+        updater: (task) => ({ ...task, list_id: newListId }),
+      });
 
       try {
         const { task: updatedTask } = await updateWorkspaceTask(wsId, taskId, {
           list_id: newListId,
         });
         // Update sender's own cache with DB-computed timestamps
-        queryClient.setQueryData(
-          ['tasks', boardId],
-          (oldTasks: any[] | undefined) => {
-            if (!oldTasks) return oldTasks;
-            return oldTasks.map((task: any) =>
-              task.id === taskId
-                ? {
-                    ...task,
-                    completed_at: updatedTask.completed_at,
-                    closed_at: updatedTask.closed_at,
-                  }
-                : task
-            );
-          }
-        );
+        patchTaskInVisibleCaches({
+          queryClient,
+          boardId,
+          taskId,
+          updater: (task) => ({
+            ...task,
+            completed_at: updatedTask.completed_at,
+            closed_at: updatedTask.closed_at,
+          }),
+        });
         broadcast?.('task:upsert', {
           task: {
             id: taskId,
@@ -379,7 +378,7 @@ export function useTaskMutations({
       } catch (e: any) {
         console.error('Failed updating list', e);
         // Revert optimistic update on error
-        await invalidateTaskCaches(queryClient, boardId);
+        restoreVisibleTaskCaches(queryClient, cacheSnapshot);
         toast({
           title: 'Failed to update list',
           description: e.message || 'Please try again',
@@ -412,15 +411,15 @@ export function useTaskMutations({
 
       // Optimistically update the cache instead of invalidating
       // This prevents conflicts with realtime sync
-      queryClient.setQueryData(
-        ['tasks', boardId],
-        (oldTasks: any[] | undefined) => {
-          if (!oldTasks) return oldTasks;
-          return oldTasks.map((task) =>
-            task.id === taskId ? { ...task, name: trimmedName } : task
-          );
-        }
-      );
+      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
+        taskId,
+      ]);
+      patchTaskInVisibleCaches({
+        queryClient,
+        boardId,
+        taskId,
+        updater: (task) => ({ ...task, name: trimmedName }),
+      });
 
       try {
         const { task } = await updateWorkspaceTask(wsId, taskId, {
@@ -432,8 +431,8 @@ export function useTaskMutations({
         triggerRefresh();
       } catch (e: any) {
         console.error('Failed updating task name', e);
-        // Revert optimistic update on error by invalidating to refetch
-        await invalidateTaskCaches(queryClient, boardId);
+        // Revert optimistic update without refetching visible board caches.
+        restoreVisibleTaskCaches(queryClient, cacheSnapshot);
         toast({
           title: 'Failed to update task name',
           description: e.message || 'Please try again',

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/use-task-relationships.test.tsx

@@ -146,4 +146,67 @@ describe('useTaskRelationships', () => {
       ])
     ).toEqual([newLabel, existingLabel]);
   });
+
+  it('patches visible task caches when labels change without invalidating board task queries', async () => {
+    const cachedTask = {
+      id: 'task-1',
+      labels: [],
+    } as unknown as Task;
+
+    queryClient.setQueryData(['tasks', 'board-1'], [cachedTask]);
+    queryClient.setQueryData(['tasks-full', 'board-1', 'all'], [cachedTask]);
+    queryClient.setQueryData(['task', 'task-1'], cachedTask);
+    const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries');
+
+    const { result } = renderHook(
+      () =>
+        useTaskRelationships({
+          wsId: 'personal',
+          taskId: 'task-1',
+          isCreateMode: false,
+          boardId: 'board-1',
+          selectedLabels: [],
+          selectedAssignees: [],
+          selectedProjects: [],
+          newLabelName: '',
+          newLabelColor: '#14b8a6',
+          newProjectName: '',
+          setSelectedLabels: vi.fn(),
+          setSelectedAssignees: vi.fn(),
+          setSelectedProjects: vi.fn(),
+          setAvailableLabels: vi.fn(),
+          setNewLabelName: vi.fn(),
+          setNewLabelColor: vi.fn(),
+          setNewProjectName: vi.fn(),
+          setShowNewLabelDialog: vi.fn(),
+          setShowNewProjectDialog: vi.fn(),
+          onUpdate: vi.fn(),
+        }),
+      { wrapper }
+    );
+
+    await act(async () => {
+      await result.current.toggleLabel(newLabel);
+    });
+
+    expect(
+      queryClient.getQueryData<Task[]>(['tasks', 'board-1'])?.[0]?.labels
+    ).toEqual([newLabel]);
+    expect(
+      queryClient.getQueryData<Task[]>(['tasks-full', 'board-1', 'all'])?.[0]
+        ?.labels
+    ).toEqual([newLabel]);
+    expect(queryClient.getQueryData<Task>(['task', 'task-1'])?.labels).toEqual([
+      newLabel,
+    ]);
+    expect(invalidateSpy).not.toHaveBeenCalledWith({
+      queryKey: ['tasks', 'board-1'],
+    });
+    expect(invalidateSpy).not.toHaveBeenCalledWith({
+      queryKey: ['tasks-full', 'board-1'],
+    });
+    expect(mocks.broadcast).toHaveBeenCalledWith('task:relations-changed', {
+      taskId: 'task-1',
+    });
+  });
 });

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/use-task-relationships.ts

@@ -1,7 +1,5 @@
 import { type QueryClient, useQueryClient } from '@tanstack/react-query';
-import type { Task } from '@tuturuuu/types/primitives/Task';
 import { toast } from '@tuturuuu/ui/sonner';
-import { invalidateTaskCaches } from '@tuturuuu/utils/task-helper';
 import {
   type Dispatch,
   type SetStateAction,
@@ -11,9 +9,11 @@ import {
 import { getRandomNewLabelColor } from '../../../utils/taskConstants';
 import {
   type BoardBroadcastFn,
+  getActiveBoardRefresh,
   getActiveBroadcast,
   useBoardBroadcast,
 } from '../../board-broadcast-context';
+import { patchTaskInVisibleCaches } from '../../task-cache-patches';
 import type {
   WorkspaceTaskAssignee,
   WorkspaceTaskLabel,
@@ -129,6 +129,32 @@ function upsertWorkspaceLabelCaches({
   }
 }
 
+function normalizeTaskAssignees(assignees: WorkspaceTaskAssignee[]) {
+  return assignees
+    .map((assignee) => {
+      const id = assignee.user_id || assignee.id;
+      if (!id) return null;
+
+      return {
+        id,
+        display_name: assignee.display_name ?? undefined,
+        email: assignee.email ?? undefined,
+        avatar_url: assignee.avatar_url ?? undefined,
+      };
+    })
+    .filter((assignee): assignee is NonNullable<typeof assignee> =>
+      Boolean(assignee)
+    );
+}
+
+function normalizeTaskProjects(projects: WorkspaceTaskProject[]) {
+  return projects.map((project) => ({
+    id: project.id,
+    name: project.name,
+    status: project.status ?? 'unknown',
+  }));
+}
+
 export function useTaskRelationships({
   wsId,
   labelCacheWorkspaceId,
@@ -189,9 +215,18 @@ export function useTaskRelationships({
         });
 
         setSelectedLabels(nextSelectedLabels);
-        await invalidateTaskCaches(queryClient, boardId);
+        patchTaskInVisibleCaches({
+          queryClient,
+          boardId,
+          taskId,
+          updater: (task) => ({
+            ...task,
+            labels: nextSelectedLabels,
+          }),
+        });
         queryClient.invalidateQueries({ queryKey: ['task-history'] });
         broadcast?.('task:relations-changed', { taskId });
+        getActiveBoardRefresh()?.({ invalidateTasks: false });
         onUpdate();
       } catch (error: unknown) {
         toast.error('Label update failed', {
@@ -246,30 +281,18 @@ export function useTaskRelationships({
         });
 
         setSelectedAssignees(nextSelectedAssignees);
-        queryClient.setQueryData(
-          ['tasks', boardId],
-          (old: Task[] | undefined) => {
-            if (!old) return old;
-            return old.map((task) => {
-              if (task.id !== taskId) return task;
-              const currentAssignees = task.assignees || [];
-              const newAssignees = exists
-                ? currentAssignees.filter((assignee) => assignee.id !== userId)
-                : [
-                    ...currentAssignees,
-                    {
-                      id: userId,
-                      display_name: member.display_name,
-                      email: member.email,
-                      avatar_url: member.avatar_url,
-                    },
-                  ];
-              return { ...task, assignees: newAssignees };
-            });
-          }
-        );
+        patchTaskInVisibleCaches({
+          queryClient,
+          boardId,
+          taskId,
+          updater: (task) => ({
+            ...task,
+            assignees: normalizeTaskAssignees(nextSelectedAssignees),
+          }),
+        });
         queryClient.invalidateQueries({ queryKey: ['task-history'] });
         broadcast?.('task:relations-changed', { taskId });
+        getActiveBoardRefresh()?.({ invalidateTasks: false });
         onUpdate();
       } catch (error: unknown) {
         toast.error('Assignee update failed', {
@@ -315,22 +338,18 @@ export function useTaskRelationships({
         });
 
         setSelectedProjects(nextSelectedProjects);
-        queryClient.setQueryData(
-          ['tasks', boardId],
-          (old: Task[] | undefined) => {
-            if (!old) return old;
-            return old.map((task) => {
-              if (task.id !== taskId) return task;
-              const currentProjects = task.projects || [];
-              const newProjects = exists
-                ? currentProjects.filter((entry) => entry.id !== project.id)
-                : [...currentProjects, project];
-              return { ...task, projects: newProjects };
-            });
-          }
-        );
+        patchTaskInVisibleCaches({
+          queryClient,
+          boardId,
+          taskId,
+          updater: (task) => ({
+            ...task,
+            projects: normalizeTaskProjects(nextSelectedProjects),
+          }),
+        });
         queryClient.invalidateQueries({ queryKey: ['task-history'] });
         broadcast?.('task:relations-changed', { taskId });
+        getActiveBoardRefresh()?.({ invalidateTasks: false });
         onUpdate();
       } catch (error: unknown) {
         toast.error('Project update failed', {
@@ -393,23 +412,17 @@ export function useTaskRelationships({
         });
 
         setSelectedLabels(nextSelectedLabels);
-        queryClient.setQueryData(
-          ['tasks', boardId],
-          (old: Task[] | undefined) => {
-            if (!old) return old;
-            return old.map((task) => {
-              if (task.id !== taskId) return task;
-              const currentLabels = task.labels || [];
-              return {
-                ...task,
-                labels: [...currentLabels, newLabel].sort((a, b) =>
-                  compareLabelsByName(a, b)
-                ),
-              };
-            });
-          }
-        );
+        patchTaskInVisibleCaches({
+          queryClient,
+          boardId,
+          taskId,
+          updater: (task) => ({
+            ...task,
+            labels: nextSelectedLabels,
+          }),
+        });
         broadcast?.('task:relations-changed', { taskId });
+        getActiveBoardRefresh()?.({ invalidateTasks: false });
         onUpdate();
         toast.success('Label created & linked', {
           description: 'New label added and attached to this task.',
@@ -485,21 +498,17 @@ export function useTaskRelationships({
         });
 
         setSelectedProjects(nextSelectedProjects);
-        queryClient.setQueryData(
-          ['tasks', boardId],
-          (old: Task[] | undefined) => {
-            if (!old) return old;
-            return old.map((task) => {
-              if (task.id !== taskId) return task;
-              const currentProjects = task.projects || [];
-              return {
-                ...task,
-                projects: [...currentProjects, newProject],
-              };
-            });
-          }
-        );
+        patchTaskInVisibleCaches({
+          queryClient,
+          boardId,
+          taskId,
+          updater: (task) => ({
+            ...task,
+            projects: normalizeTaskProjects(nextSelectedProjects),
+          }),
+        });
         broadcast?.('task:relations-changed', { taskId });
+        getActiveBoardRefresh()?.({ invalidateTasks: false });
         onUpdate();
         toast.success('Project created & linked', {
           description: 'New project added and attached to this task.',