@tuturuuu/ui 0.8.0 → 0.10.0

package/src/components/ui/tu-do/hooks/__tests__/useTaskProjectManagement.test.tsx

@@ -0,0 +1,144 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, renderHook } from '@testing-library/react';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+import type { ReactNode } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useTaskProjectManagement } from '../useTaskProjectManagement';
+
+vi.mock('@tuturuuu/ui/sonner', () => ({
+  toast: {
+    error: vi.fn(),
+    success: vi.fn(),
+    warning: vi.fn(),
+  },
+}));
+
+vi.mock('@tuturuuu/internal-api/tasks', () => ({
+  createWorkspaceTaskProject: vi.fn(),
+  updateWorkspaceTask: vi.fn(),
+}));
+
+describe('useTaskProjectManagement', () => {
+  let queryClient: QueryClient;
+  let mockUpdateWorkspaceTask: any;
+
+  const project = {
+    id: 'project-1',
+    name: 'Roadmap',
+    status: 'active',
+  };
+
+  const mockTask = {
+    id: 'task-1',
+    name: 'Test Task',
+    list_id: 'list-1',
+    display_number: 1,
+    created_at: '2026-01-01T00:00:00.000Z',
+    projects: [],
+  } satisfies Task;
+
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+
+  beforeEach(async () => {
+    queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+        mutations: { retry: false },
+      },
+    });
+
+    const { updateWorkspaceTask } = await import(
+      '@tuturuuu/internal-api/tasks'
+    );
+    mockUpdateWorkspaceTask = updateWorkspaceTask as any;
+
+    vi.clearAllMocks();
+    mockUpdateWorkspaceTask.mockResolvedValue({ task: { id: 'task-1' } });
+  });
+
+  it('updates full-board and task detail caches without invalidating visible board queries', async () => {
+    queryClient.setQueryData(['tasks', 'board-1'], [mockTask]);
+    queryClient.setQueryData(['tasks-full', 'board-1', 'all'], [mockTask]);
+    queryClient.setQueryData(['task', 'task-1'], mockTask);
+    const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries');
+
+    const { result } = renderHook(
+      () =>
+        useTaskProjectManagement({
+          task: mockTask,
+          boardId: 'board-1',
+          workspaceProjects: [project],
+          workspaceId: 'ws-1',
+          taskId: 'task-1',
+        }),
+      { wrapper }
+    );
+
+    await act(async () => {
+      await result.current.toggleTaskProject('project-1');
+    });
+
+    expect(
+      queryClient
+        .getQueryData<Task[]>(['tasks-full', 'board-1', 'all'])?.[0]
+        ?.projects?.some((entry) => entry.id === 'project-1')
+    ).toBe(true);
+    expect(
+      queryClient
+        .getQueryData<Task>(['task', 'task-1'])
+        ?.projects?.some((entry) => entry.id === 'project-1')
+    ).toBe(true);
+    expect(invalidateSpy).not.toHaveBeenCalledWith({
+      queryKey: ['tasks', 'board-1'],
+    });
+    expect(invalidateSpy).not.toHaveBeenCalledWith({
+      queryKey: ['tasks-full', 'board-1'],
+    });
+  });
+
+  it('rolls back every visible cache when the project update fails', async () => {
+    const taskWithProject = {
+      ...mockTask,
+      projects: [project],
+    } as Task;
+    mockUpdateWorkspaceTask.mockRejectedValueOnce(new Error('Database error'));
+    queryClient.setQueryData(['tasks', 'board-1'], [taskWithProject]);
+    queryClient.setQueryData(
+      ['tasks-full', 'board-1', 'all'],
+      [taskWithProject]
+    );
+    queryClient.setQueryData(['task', 'task-1'], taskWithProject);
+
+    const { result } = renderHook(
+      () =>
+        useTaskProjectManagement({
+          task: taskWithProject,
+          boardId: 'board-1',
+          workspaceProjects: [project],
+          workspaceId: 'ws-1',
+          taskId: 'task-1',
+        }),
+      { wrapper }
+    );
+
+    await act(async () => {
+      await result.current.toggleTaskProject('project-1');
+    });
+
+    expect(queryClient.getQueryData<Task[]>(['tasks', 'board-1'])).toEqual([
+      taskWithProject,
+    ]);
+    expect(
+      queryClient.getQueryData<Task[]>(['tasks-full', 'board-1', 'all'])
+    ).toEqual([taskWithProject]);
+    expect(queryClient.getQueryData<Task>(['task', 'task-1'])).toEqual(
+      taskWithProject
+    );
+  });
+});

package/src/components/ui/tu-do/hooks/useTaskDialog.ts

@@ -4,6 +4,7 @@ import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
 import type { TaskFilters } from '@tuturuuu/ui/tu-do/boards/boardId/task-filter';
 import {
   type PendingRelationshipType,
+  type TaskAssigneeMemberSource,
   useTaskDialogContext,
 } from '../providers/task-dialog-provider';
 import type { SharedTaskContext } from '../shared/task-edit-dialog/hooks/use-task-data';
@@ -50,6 +51,10 @@ export function useTaskDialog(): {
       taskWsId?: string;
       /** Whether the task's workspace is personal (affects realtime features) */
       taskWorkspacePersonal?: boolean;
+      /** Whether the board context should expose assignee controls */
+      canUseBoardAssignees?: boolean;
+      /** Where assignee candidates should be loaded from */
+      assigneeMemberSource?: TaskAssigneeMemberSource;
     }
   ) => void;
   openTaskById: (
@@ -62,6 +67,8 @@ export function useTaskDialog(): {
       taskWsId?: string;
       taskWorkspacePersonal?: boolean;
       taskWorkspaceTier?: WorkspaceProductTier;
+      canUseBoardAssignees?: boolean;
+      assigneeMemberSource?: TaskAssigneeMemberSource;
       initialSharedContext?: SharedTaskContext;
     }
   ) => Promise<boolean>;

package/src/components/ui/tu-do/hooks/useTaskLabelManagement.ts

@@ -9,7 +9,17 @@ import type { TaskLabel as DbTaskLabel } from '@tuturuuu/types/db';
 import type { Task } from '@tuturuuu/types/primitives/Task';
 import { toast } from '@tuturuuu/ui/sonner';
 import { useState } from 'react';
-import { useBoardBroadcast } from '../shared/board-broadcast-context';
+import {
+  getActiveBoardRefresh,
+  useBoardBroadcast,
+} from '../shared/board-broadcast-context';
+import {
+  getTaskFromVisibleCaches,
+  patchTaskInVisibleCaches,
+  restoreTasksFromVisibleCacheSnapshot,
+  restoreVisibleTaskCaches,
+  snapshotVisibleTaskCaches,
+} from '../shared/task-cache-patches';
 import { getRandomNewLabelColor } from '../utils/taskConstants';
 
 type WorkspaceTaskLabel = Pick<
@@ -68,10 +78,14 @@ export function useTaskLabelManagement({
 
     // CRITICAL: Get current task state from cache instead of stale prop
     // This ensures we read the most up-to-date state after optimistic updates
-    const currentTask = taskId
-      ? ((queryClient.getQueryData(['task', taskId]) as Task | undefined) ??
-        task)
-      : task;
+    const canonicalTaskId = taskId ?? task.id;
+    const currentTask =
+      getTaskFromVisibleCaches({
+        queryClient,
+        boardId,
+        taskId: canonicalTaskId,
+        fallback: task,
+      }) ?? task;
 
     // Check if we're in multi-select mode with multiple tasks selected
     const shouldBulkUpdate =
@@ -86,11 +100,17 @@ export function useTaskLabelManagement({
 
     // Cancel any outgoing refetches
     await queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
+    await queryClient.cancelQueries({ queryKey: ['tasks-full', boardId] });
 
     // Snapshot the previous value BEFORE optimistic update
     const previousTasks = queryClient.getQueryData(['tasks', boardId]) as
       | Task[]
       | undefined;
+    const cacheSnapshot = snapshotVisibleTaskCaches(
+      queryClient,
+      boardId,
+      tasksToUpdate
+    );
 
     // Determine action: remove if ALL selected tasks have the label, add otherwise
     // Use currentTask from cache, not stale task prop
@@ -112,6 +132,13 @@ export function useTaskLabelManagement({
       const fromBoardCache = previousTasks?.find((ct) => ct.id === taskId);
       if (fromBoardCache) return fromBoardCache;
 
+      const fromVisibleCaches = getTaskFromVisibleCaches({
+        queryClient,
+        boardId,
+        taskId,
+      });
+      if (fromVisibleCaches) return fromVisibleCaches;
+
       // Fallback to individual task cache (for tasks not in board view)
       if (taskId === currentTask.id) return currentTask;
 
@@ -135,63 +162,36 @@ export function useTaskLabelManagement({
 
     // Get label details from workspace labels for optimistic update
     const label = workspaceLabels.find((l) => l.id === labelId);
+    const fallbackLabel = label || {
+      id: labelId,
+      name: 'Unknown',
+      color: '#3b82f6',
+      created_at: new Date().toISOString(),
+    };
 
     // Optimistically update the cache - only update tasks that actually change
-    queryClient.setQueryData(['tasks', boardId], (old: Task[] | undefined) => {
-      if (!old) return old;
-      return old.map((t) => {
-        if (active && tasksToRemoveFrom.includes(t.id)) {
-          // Remove the label
-          return {
-            ...t,
-            labels: t.labels?.filter((l) => l.id !== labelId) || [],
-          };
-        } else if (!active && tasksNeedingLabel.includes(t.id)) {
-          // Add the label
-          return {
-            ...t,
-            labels: [
-              ...(t.labels || []),
-              label || {
-                id: labelId,
-                name: 'Unknown',
-                color: '#3b82f6',
-                created_at: new Date().toISOString(),
-              },
-            ],
-          };
-        }
-        return t;
-      });
-    });
-
-    // CRITICAL: Also update the individual task cache if taskId is provided
-    // This ensures the chip menu's task cache stays in sync with the board cache
-    if (taskId) {
-      queryClient.setQueryData(['task', taskId], (old: Task | undefined) => {
-        if (!old) return old;
-        if (active && tasksToRemoveFrom.includes(taskId)) {
-          // Remove the label
-          return {
-            ...old,
-            labels: old.labels?.filter((l) => l.id !== labelId) || [],
-          };
-        } else if (!active && tasksNeedingLabel.includes(taskId)) {
-          // Add the label
+    for (const tid of active ? tasksToRemoveFrom : tasksNeedingLabel) {
+      patchTaskInVisibleCaches({
+        queryClient,
+        boardId,
+        taskId: tid,
+        updater: (cachedTask) => {
+          if (active) {
+            return {
+              ...cachedTask,
+              labels: cachedTask.labels?.filter((l) => l.id !== labelId) || [],
+            };
+          }
+
+          if (cachedTask.labels?.some((l) => l.id === labelId)) {
+            return cachedTask;
+          }
+
           return {
-            ...old,
-            labels: [
-              ...(old.labels || []),
-              label || {
-                id: labelId,
-                name: 'Unknown',
-                color: '#3b82f6',
-                created_at: new Date().toISOString(),
-              },
-            ],
+            ...cachedTask,
+            labels: [...(cachedTask.labels || []), fallbackLabel],
           };
-        }
-        return old;
+        },
       });
     }
 
@@ -201,33 +201,36 @@ export function useTaskLabelManagement({
           ? { baseUrl: window.location.origin }
           : undefined;
       let successCount = 0;
+      const succeededTaskIds: string[] = [];
 
       if (active) {
-        for (const taskId of tasksToRemoveFrom) {
+        for (const tid of tasksToRemoveFrom) {
           try {
             await removeWorkspaceTaskLabel(
               workspaceId,
-              taskId,
+              tid,
               labelId,
               internalApiOptions
             );
             successCount++;
+            succeededTaskIds.push(tid);
           } catch (error) {
-            console.error(`Failed to remove label from task ${taskId}:`, error);
+            console.error(`Failed to remove label from task ${tid}:`, error);
           }
         }
       } else {
-        for (const taskId of tasksNeedingLabel) {
+        for (const tid of tasksNeedingLabel) {
           try {
             await addWorkspaceTaskLabel(
               workspaceId,
-              taskId,
+              tid,
               labelId,
               internalApiOptions
             );
             successCount++;
+            succeededTaskIds.push(tid);
           } catch (error) {
-            console.error(`Failed to add label to task ${taskId}:`, error);
+            console.error(`Failed to add label to task ${tid}:`, error);
           }
         }
       }
@@ -240,10 +243,22 @@ export function useTaskLabelManagement({
         throw new Error('Failed to update any tasks');
       }
 
+      const failedTaskIds = (
+        active ? tasksToRemoveFrom : tasksNeedingLabel
+      ).filter((tid) => !succeededTaskIds.includes(tid));
+      restoreTasksFromVisibleCacheSnapshot({
+        queryClient,
+        snapshot: cacheSnapshot,
+        taskIds: failedTaskIds,
+      });
+
       // Broadcast relation changes for all affected tasks
-      for (const tid of active ? tasksToRemoveFrom : tasksNeedingLabel) {
+      for (const tid of succeededTaskIds) {
         broadcast?.('task:relations-changed', { taskId: tid });
       }
+      if (succeededTaskIds.length > 0) {
+        getActiveBoardRefresh()?.({ invalidateTasks: false });
+      }
 
       toast.success(active ? 'Label removed' : 'Label added', {
         description:
@@ -253,9 +268,7 @@ export function useTaskLabelManagement({
       // Don't auto-clear selection - let user manually clear with "Clear" button
     } catch (e: any) {
       // Rollback on error
-      if (previousTasks) {
-        queryClient.setQueryData(['tasks', boardId], previousTasks);
-      }
+      restoreVisibleTaskCaches(queryClient, cacheSnapshot);
       console.error('Failed to toggle label:', e);
       toast.error('Error', {
         description: 'Failed to update label. Please try again.',
@@ -306,48 +319,44 @@ export function useTaskLabelManagement({
 
       // Auto-apply the newly created label to this task
       let linkSucceeded = false;
-      let previousTasks: unknown;
+      const canonicalTaskId = taskId ?? task.id;
+      let cacheSnapshot:
+        | ReturnType<typeof snapshotVisibleTaskCaches>
+        | undefined;
       try {
         // Cancel any outgoing refetches
         await queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
+        await queryClient.cancelQueries({ queryKey: ['tasks-full', boardId] });
 
         // Snapshot the previous value
-        previousTasks = queryClient.getQueryData(['tasks', boardId]);
+        cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
+          canonicalTaskId,
+        ]);
 
         // Optimistically update the cache
-        queryClient.setQueryData(
-          ['tasks', boardId],
-          (old: any[] | undefined) => {
-            if (!old) return old;
-            return old.map((t) => {
-              if (t.id === task.id) {
-                return {
-                  ...t,
-                  labels: [...(t.labels || []), newLabel],
-                };
-              }
-              return t;
-            });
-          }
-        );
-
-        // CRITICAL: Also update individual task cache if taskId is provided
-        if (taskId) {
-          queryClient.setQueryData(
-            ['task', taskId],
-            (old: Task | undefined) => {
-              if (!old) return old;
-              return {
-                ...old,
-                labels: [...(old.labels || []), newLabel],
-              };
+        patchTaskInVisibleCaches({
+          queryClient,
+          boardId,
+          taskId: canonicalTaskId,
+          updater: (cachedTask) => {
+            if (cachedTask.labels?.some((label) => label.id === newLabel.id)) {
+              return cachedTask;
             }
-          );
-        }
+
+            return {
+              ...cachedTask,
+              labels: [...(cachedTask.labels || []), newLabel],
+            };
+          },
+        });
 
         const taskState =
-          (queryClient.getQueryData(['task', task.id]) as Task | undefined) ??
-          task;
+          getTaskFromVisibleCaches({
+            queryClient,
+            boardId,
+            taskId: canonicalTaskId,
+            fallback: task,
+          }) ?? task;
         const nextLabelIds = [
           ...new Set([
             ...(taskState.labels ?? []).map((entry) => entry.id),
@@ -357,7 +366,7 @@ export function useTaskLabelManagement({
 
         await updateWorkspaceTask(
           workspaceId,
-          task.id,
+          canonicalTaskId,
           {
             label_ids: nextLabelIds,
           },
@@ -368,19 +377,19 @@ export function useTaskLabelManagement({
         linkSucceeded = true;
       } catch (linkErr: any) {
         // Rollback on error
-        queryClient.setQueryData(['tasks', boardId], previousTasks);
+        if (cacheSnapshot) {
+          restoreVisibleTaskCaches(queryClient, cacheSnapshot);
+        }
         toast.error(
           'The label was created but could not be attached to the task. Refresh and try manually.'
         );
-        if (taskId) {
-          queryClient.invalidateQueries({ queryKey: ['task', taskId] });
-        }
         console.error('Failed to auto-apply new label', linkErr);
       }
 
       // Only show success toast and reset form if link succeeded
       if (linkSucceeded) {
-        broadcast?.('task:relations-changed', { taskId: task.id });
+        broadcast?.('task:relations-changed', { taskId: canonicalTaskId });
+        getActiveBoardRefresh()?.({ invalidateTasks: false });
 
         // Reset form and close dialog
         setNewLabelName('');