@tuturuuu/ui 0.14.0 → 0.16.0

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

@@ -0,0 +1,231 @@
+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 { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { updateWorkspaceTask } from '../task-api';
+import {
+  type UseTaskMutationsProps,
+  useTaskMutations,
+} from '../use-task-mutations';
+
+vi.mock('../task-api', () => ({
+  updateWorkspaceTask: vi.fn(),
+}));
+
+vi.mock('@tuturuuu/ui/hooks/use-toast', () => ({
+  useToast: () => ({ toast: vi.fn() }),
+}));
+
+describe('useTaskMutations', () => {
+  let queryClient: QueryClient;
+
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+
+  const personalOverlayTask = {
+    id: 'task-1',
+    name: 'Overlay task',
+    description: '',
+    display_number: 1,
+    created_at: '2026-07-07T00:00:00.000Z',
+    list_id: 'personal-list',
+    personal_board_id: 'personal-board',
+    personal_list_id: 'personal-list',
+    personal_sort_key: 1234,
+    sort_key: 1234,
+    source_workspace_id: 'source-ws',
+    source_board_id: 'source-board',
+    source_list_id: 'source-list',
+    source_list_name: 'Source list',
+    source_list_status: 'active',
+    is_personal_external: true,
+    priority: 'normal',
+    estimation_points: 3,
+    end_date: null,
+    labels: [],
+    assignees: [],
+    projects: [],
+  } satisfies Task;
+
+  const sourceTask = {
+    ...personalOverlayTask,
+    list_id: 'source-list',
+    personal_board_id: null,
+    personal_list_id: null,
+    personal_sort_key: null,
+    is_personal_external: false,
+  } satisfies Task;
+
+  function makeProps(
+    overrides: Partial<UseTaskMutationsProps> = {}
+  ): UseTaskMutationsProps {
+    return {
+      wsId: 'source-ws',
+      taskId: 'task-1',
+      isCreateMode: false,
+      boardId: 'source-board',
+      visibleBoardId: 'personal-board',
+      visibleTaskSnapshot: personalOverlayTask,
+      estimationPoints: 3,
+      priority: 'normal',
+      selectedListId: 'source-list',
+      taskName: 'Overlay task',
+      setEstimationPoints: vi.fn(),
+      setPriority: vi.fn(),
+      setStartDate: vi.fn(),
+      setEndDate: vi.fn(),
+      setSelectedListId: vi.fn(),
+      fallbackBroadcast: null,
+      onUpdate: vi.fn(),
+      ...overrides,
+    };
+  }
+
+  function getPersonalOverlayCacheTask() {
+    return queryClient.getQueryData<Task[]>(['tasks', 'personal-board'])?.[0] as
+      | (Task & { _localMutationAt?: number })
+      | undefined;
+  }
+
+  beforeEach(() => {
+    queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+        mutations: { retry: false },
+      },
+    });
+    queryClient.setQueryData(
+      ['tasks', 'personal-board'],
+      [personalOverlayTask]
+    );
+    vi.mocked(updateWorkspaceTask).mockReset();
+  });
+
+  afterEach(() => {
+    queryClient.clear();
+    vi.restoreAllMocks();
+  });
+
+  it('keeps a personal external card in the personal board cache when priority changes', async () => {
+    const onUpdate = vi.fn();
+    vi.mocked(updateWorkspaceTask).mockResolvedValueOnce({
+      task: {
+        ...sourceTask,
+        priority: 'high',
+        list_id: 'source-list',
+      },
+    });
+
+    const { result } = renderHook(
+      () => useTaskMutations(makeProps({ onUpdate })),
+      { wrapper }
+    );
+
+    await act(async () => {
+      await result.current.updatePriority('high');
+    });
+
+    expect(updateWorkspaceTask).toHaveBeenCalledWith('source-ws', 'task-1', {
+      priority: 'high',
+    });
+    expect(onUpdate).not.toHaveBeenCalled();
+    expect(getPersonalOverlayCacheTask()).toMatchObject({
+      id: 'task-1',
+      priority: 'high',
+      list_id: 'personal-list',
+      personal_board_id: 'personal-board',
+      personal_list_id: 'personal-list',
+      personal_sort_key: 1234,
+      source_board_id: 'source-board',
+      source_list_id: 'source-list',
+      _localMutationAt: expect.any(Number),
+    });
+  });
+
+  it('preserves personal placement while updating date, estimate, and name fields', async () => {
+    const startIso = '2026-07-08T00:00:00.000Z';
+    const endIso = '2026-07-09T00:00:00.000Z';
+    const onUpdate = vi.fn();
+
+    vi.mocked(updateWorkspaceTask)
+      .mockResolvedValueOnce({
+        task: { ...sourceTask, start_date: startIso, list_id: 'source-list' },
+      })
+      .mockResolvedValueOnce({
+        task: { ...sourceTask, end_date: endIso, list_id: 'source-list' },
+      })
+      .mockResolvedValueOnce({
+        task: {
+          ...sourceTask,
+          estimation_points: 8,
+          list_id: 'source-list',
+        },
+      })
+      .mockResolvedValueOnce({
+        task: { ...sourceTask, name: 'Renamed task', list_id: 'source-list' },
+      });
+
+    const { result } = renderHook(
+      () => useTaskMutations(makeProps({ onUpdate })),
+      { wrapper }
+    );
+
+    await act(async () => {
+      await result.current.updateStartDate(new Date(startIso));
+      await result.current.updateEndDate(new Date(endIso));
+      await result.current.updateEstimation(8);
+      await result.current.saveNameToDatabase('Renamed task');
+    });
+
+    expect(onUpdate).not.toHaveBeenCalled();
+    expect(getPersonalOverlayCacheTask()).toMatchObject({
+      id: 'task-1',
+      name: 'Renamed task',
+      list_id: 'personal-list',
+      personal_list_id: 'personal-list',
+      start_date: startIso,
+      end_date: endIso,
+      estimation_points: 8,
+      _localMutationAt: expect.any(Number),
+    });
+  });
+
+  it('keeps normal source-board property refresh behavior unchanged', async () => {
+    const onUpdate = vi.fn();
+    queryClient.setQueryData(['tasks', 'source-board'], [sourceTask]);
+    vi.mocked(updateWorkspaceTask).mockResolvedValueOnce({
+      task: { ...sourceTask, priority: 'high' },
+    });
+
+    const { result } = renderHook(
+      () =>
+        useTaskMutations(
+          makeProps({
+            onUpdate,
+            visibleBoardId: undefined,
+            visibleTaskSnapshot: undefined,
+          })
+        ),
+      { wrapper }
+    );
+
+    await act(async () => {
+      await result.current.updatePriority('high');
+    });
+
+    const sourceCacheTask = queryClient.getQueryData<Task[]>([
+      'tasks',
+      'source-board',
+    ])?.[0] as (Task & { _localMutationAt?: number }) | undefined;
+
+    expect(onUpdate).toHaveBeenCalledTimes(1);
+    expect(sourceCacheTask).toMatchObject({
+      id: 'task-1',
+      priority: 'high',
+      list_id: 'source-list',
+    });
+    expect(sourceCacheTask?._localMutationAt).toBeUndefined();
+  });
+});

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

@@ -4,9 +4,10 @@ import {
   updateCurrentUserTaskSchedulingSettings,
 } from '@tuturuuu/internal-api';
 import type { TaskPriority } from '@tuturuuu/types/primitives/Priority';
-import type { CalendarHoursType } from '@tuturuuu/types/primitives/Task';
+import type { CalendarHoursType, Task } from '@tuturuuu/types/primitives/Task';
 import { useToast } from '@tuturuuu/ui/hooks/use-toast';
 import { useCallback, useState } from 'react';
+import { isPersonalExternalOverlayTask } from '../../../../../../lib/task-personal-external';
 import {
   type BoardBroadcastFn,
   getActiveBroadcast,
@@ -33,6 +34,8 @@ export interface UseTaskMutationsProps {
   taskId?: string;
   isCreateMode: boolean;
   boardId: string;
+  visibleBoardId?: string;
+  visibleTaskSnapshot?: Partial<Task>;
   estimationPoints: number | null;
   priority: TaskPriority | null;
   selectedListId?: string;
@@ -66,6 +69,27 @@ export interface UseTaskMutationsReturn {
   schedulingSaving: boolean;
 }
 
+type PropertyPatch = Pick<
+  Partial<Task>,
+  'name' | 'priority' | 'start_date' | 'end_date' | 'estimation_points'
+>;
+
+function hasPersonalExternalVisibleContext({
+  boardId,
+  visibleBoardId,
+  visibleTaskSnapshot,
+}: {
+  boardId: string;
+  visibleBoardId?: string;
+  visibleTaskSnapshot?: Partial<Task>;
+}) {
+  return Boolean(
+    visibleBoardId &&
+      visibleBoardId !== boardId &&
+      isPersonalExternalOverlayTask(visibleTaskSnapshot as Task | undefined)
+  );
+}
+
 /**
  * Custom hook for task database mutations (CRUD operations on task properties)
  * Extracted from task-edit-dialog.tsx to improve maintainability
@@ -75,6 +99,8 @@ export function useTaskMutations({
   taskId,
   isCreateMode,
   boardId,
+  visibleBoardId,
+  visibleTaskSnapshot,
   estimationPoints,
   priority,
   selectedListId,
@@ -94,16 +120,57 @@ export function useTaskMutations({
     contextBroadcast ?? getActiveBroadcast() ?? fallbackBroadcast;
   const [estimationSaving, setEstimationSaving] = useState(false);
   const [schedulingSaving, setSchedulingSaving] = useState(false);
+  const hasPersonalExternalContext = hasPersonalExternalVisibleContext({
+    boardId,
+    visibleBoardId,
+    visibleTaskSnapshot,
+  });
+  const propertyCacheBoardId =
+    hasPersonalExternalContext && visibleBoardId ? visibleBoardId : boardId;
 
   // Helper to trigger refresh after successful mutations
   // Note: The kanban board uses realtime subscriptions directly and doesn't
   // register a refresh callback via the task dialog system, so calling onUpdate
   // here won't conflict with realtime sync on the board page.
   // Also invalidate task-history so the activity section updates immediately.
-  const triggerRefresh = useCallback(() => {
+  const triggerRefresh = useCallback(
+    (options?: { refreshBoard?: boolean }) => {
+      const refreshBoard = options?.refreshBoard ?? true;
+
+      queryClient.invalidateQueries({ queryKey: ['task-history'] });
+      if (refreshBoard) {
+        onUpdate();
+      }
+    },
+    [queryClient, onUpdate]
+  );
+
+  const patchPropertyInVisibleCaches = useCallback(
+    (patch: PropertyPatch) => {
+      if (!taskId) return;
+
+      patchTaskInVisibleCaches({
+        queryClient,
+        boardId: propertyCacheBoardId,
+        taskId,
+        updater: (task) => ({
+          ...task,
+          ...patch,
+          ...(hasPersonalExternalContext
+            ? { _localMutationAt: Date.now() }
+            : {}),
+        }),
+      });
+    },
+    [hasPersonalExternalContext, propertyCacheBoardId, queryClient, taskId]
+  );
+
+  const triggerPropertyRefresh = useCallback(() => {
     queryClient.invalidateQueries({ queryKey: ['task-history'] });
-    onUpdate();
-  }, [queryClient, onUpdate]);
+    if (!hasPersonalExternalContext) {
+      onUpdate();
+    }
+  }, [hasPersonalExternalContext, queryClient, onUpdate]);
 
   const updateEstimation = useCallback(
     async (points: number | null) => {
@@ -113,29 +180,30 @@ export function useTaskMutations({
         return;
       }
       setEstimationSaving(true);
-      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
-        taskId,
-      ]);
+      const cacheSnapshot = snapshotVisibleTaskCaches(
+        queryClient,
+        propertyCacheBoardId,
+        [taskId]
+      );
 
       // Optimistic update - prevents flicker by updating cache immediately
-      patchTaskInVisibleCaches({
-        queryClient,
-        boardId,
-        taskId,
-        updater: (task) => ({ ...task, estimation_points: points }),
-      });
+      patchPropertyInVisibleCaches({ estimation_points: points });
 
       try {
         const { task } = await updateWorkspaceTask(wsId, taskId, {
           estimation_points: points,
         });
+        const updatedEstimationPoints = task.estimation_points ?? points;
+        patchPropertyInVisibleCaches({
+          estimation_points: updatedEstimationPoints,
+        });
         broadcast?.('task:upsert', {
           task: {
             id: taskId,
-            estimation_points: task.estimation_points ?? points,
+            estimation_points: updatedEstimationPoints,
           },
         });
-        triggerRefresh();
+        triggerPropertyRefresh();
       } catch (e: any) {
         console.error('Failed updating estimation', e);
         // Revert optimistic update on error
@@ -155,10 +223,11 @@ export function useTaskMutations({
       wsId,
       taskId,
       queryClient,
-      boardId,
+      propertyCacheBoardId,
       toast,
       setEstimationPoints,
-      triggerRefresh,
+      patchPropertyInVisibleCaches,
+      triggerPropertyRefresh,
       broadcast,
     ]
   );
@@ -170,29 +239,28 @@ export function useTaskMutations({
       if (isCreateMode || !taskId || taskId === 'new') {
         return;
       }
-      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
-        taskId,
-      ]);
+      const cacheSnapshot = snapshotVisibleTaskCaches(
+        queryClient,
+        propertyCacheBoardId,
+        [taskId]
+      );
 
       // Optimistic update - prevents flicker
-      patchTaskInVisibleCaches({
-        queryClient,
-        boardId,
-        taskId,
-        updater: (task) => ({ ...task, priority: newPriority }),
-      });
+      patchPropertyInVisibleCaches({ priority: newPriority });
 
       try {
         const { task } = await updateWorkspaceTask(wsId, taskId, {
           priority: newPriority,
         });
+        const updatedPriority = task.priority ?? newPriority;
+        patchPropertyInVisibleCaches({ priority: updatedPriority });
         broadcast?.('task:upsert', {
           task: {
             id: taskId,
-            priority: task.priority ?? newPriority,
+            priority: updatedPriority,
           },
         });
-        triggerRefresh();
+        triggerPropertyRefresh();
       } catch (e: any) {
         console.error('Failed updating priority', e);
         // Revert optimistic update on error
@@ -210,10 +278,11 @@ export function useTaskMutations({
       wsId,
       taskId,
       queryClient,
-      boardId,
+      propertyCacheBoardId,
       toast,
       setPriority,
-      triggerRefresh,
+      patchPropertyInVisibleCaches,
+      triggerPropertyRefresh,
       broadcast,
     ]
   );
@@ -226,29 +295,30 @@ export function useTaskMutations({
       }
 
       const dateString = newDate ? newDate.toISOString() : null;
-      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
-        taskId,
-      ]);
+      const cacheSnapshot = snapshotVisibleTaskCaches(
+        queryClient,
+        propertyCacheBoardId,
+        [taskId]
+      );
 
       // Optimistic update - prevents flicker
-      patchTaskInVisibleCaches({
-        queryClient,
-        boardId,
-        taskId,
-        updater: (task) => ({ ...task, start_date: dateString ?? undefined }),
-      });
+      patchPropertyInVisibleCaches({ start_date: dateString ?? undefined });
 
       try {
         const { task } = await updateWorkspaceTask(wsId, taskId, {
           start_date: dateString,
         });
+        const updatedStartDate = task.start_date ?? dateString;
+        patchPropertyInVisibleCaches({
+          start_date: updatedStartDate ?? undefined,
+        });
         broadcast?.('task:upsert', {
           task: {
             id: taskId,
-            start_date: task.start_date ?? dateString,
+            start_date: updatedStartDate,
           },
         });
-        triggerRefresh();
+        triggerPropertyRefresh();
       } catch (e: any) {
         console.error('Failed updating start date', e);
         // Revert optimistic update on error
@@ -265,10 +335,11 @@ export function useTaskMutations({
       wsId,
       taskId,
       queryClient,
-      boardId,
+      propertyCacheBoardId,
       toast,
       setStartDate,
-      triggerRefresh,
+      patchPropertyInVisibleCaches,
+      triggerPropertyRefresh,
       broadcast,
     ]
   );
@@ -281,29 +352,28 @@ export function useTaskMutations({
       }
 
       const dateString = newDate ? newDate.toISOString() : null;
-      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
-        taskId,
-      ]);
+      const cacheSnapshot = snapshotVisibleTaskCaches(
+        queryClient,
+        propertyCacheBoardId,
+        [taskId]
+      );
 
       // Optimistic update - prevents flicker
-      patchTaskInVisibleCaches({
-        queryClient,
-        boardId,
-        taskId,
-        updater: (task) => ({ ...task, end_date: dateString }),
-      });
+      patchPropertyInVisibleCaches({ end_date: dateString });
 
       try {
         const { task } = await updateWorkspaceTask(wsId, taskId, {
           end_date: dateString,
         });
+        const updatedEndDate = task.end_date ?? dateString;
+        patchPropertyInVisibleCaches({ end_date: updatedEndDate });
         broadcast?.('task:upsert', {
           task: {
             id: taskId,
-            end_date: task.end_date ?? dateString,
+            end_date: updatedEndDate,
           },
         });
-        triggerRefresh();
+        triggerPropertyRefresh();
       } catch (e: any) {
         console.error('Failed updating end date', e);
         // Revert optimistic update on error
@@ -320,10 +390,11 @@ export function useTaskMutations({
       wsId,
       taskId,
       queryClient,
-      boardId,
+      propertyCacheBoardId,
       toast,
       setEndDate,
-      triggerRefresh,
+      patchPropertyInVisibleCaches,
+      triggerPropertyRefresh,
       broadcast,
     ]
   );
@@ -411,24 +482,23 @@ export function useTaskMutations({
 
       // Optimistically update the cache instead of invalidating
       // This prevents conflicts with realtime sync
-      const cacheSnapshot = snapshotVisibleTaskCaches(queryClient, boardId, [
-        taskId,
-      ]);
-      patchTaskInVisibleCaches({
+      const cacheSnapshot = snapshotVisibleTaskCaches(
         queryClient,
-        boardId,
-        taskId,
-        updater: (task) => ({ ...task, name: trimmedName }),
-      });
+        propertyCacheBoardId,
+        [taskId]
+      );
+      patchPropertyInVisibleCaches({ name: trimmedName });
 
       try {
         const { task } = await updateWorkspaceTask(wsId, taskId, {
           name: trimmedName,
         });
+        const updatedName = task.name ?? trimmedName;
+        patchPropertyInVisibleCaches({ name: updatedName });
         broadcast?.('task:upsert', {
-          task: { id: taskId, name: task.name ?? trimmedName },
+          task: { id: taskId, name: updatedName },
         });
-        triggerRefresh();
+        triggerPropertyRefresh();
       } catch (e: any) {
         console.error('Failed updating task name', e);
         // Revert optimistic update without refetching visible board caches.
@@ -446,9 +516,10 @@ export function useTaskMutations({
       taskId,
       isCreateMode,
       queryClient,
-      boardId,
+      propertyCacheBoardId,
       toast,
-      triggerRefresh,
+      patchPropertyInVisibleCaches,
+      triggerPropertyRefresh,
       broadcast,
     ]
   );

package/src/components/ui/tu-do/shared/task-edit-dialog/task-dialog-actions.test.tsx

@@ -0,0 +1,68 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { fireEvent, render, screen } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { TaskDialogActions } from './task-dialog-actions';
+
+vi.mock('next-intl', () => ({
+  useTranslations: () => (key: string) => key,
+}));
+
+vi.mock('@tuturuuu/ui/sonner', () => ({
+  toast: {
+    success: vi.fn(),
+  },
+}));
+
+describe('TaskDialogActions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('shows the optional archive action in the edit menu', () => {
+    const onArchiveTask = vi.fn();
+    const onMoreMenuOpenChange = vi.fn();
+
+    render(
+      <TaskDialogActions
+        boardId="board-1"
+        hasDraft={false}
+        isCreateMode={false}
+        moreMenuOpen
+        onArchiveTask={onArchiveTask}
+        onClearDraft={vi.fn()}
+        onClose={vi.fn()}
+        onMoreMenuOpenChange={onMoreMenuOpenChange}
+        onShowDeleteDialog={vi.fn()}
+        taskId="task-1"
+        wsId="workspace-1"
+      />
+    );
+
+    fireEvent.click(screen.getByText('common.archive'));
+
+    expect(onArchiveTask).toHaveBeenCalledTimes(1);
+    expect(onMoreMenuOpenChange).toHaveBeenCalledWith(false);
+  });
+
+  it('keeps the archive action hidden when no handler is provided', () => {
+    render(
+      <TaskDialogActions
+        boardId="board-1"
+        hasDraft={false}
+        isCreateMode={false}
+        moreMenuOpen
+        onClearDraft={vi.fn()}
+        onClose={vi.fn()}
+        onMoreMenuOpenChange={vi.fn()}
+        onShowDeleteDialog={vi.fn()}
+        taskId="task-1"
+        wsId="workspace-1"
+      />
+    );
+
+    expect(screen.queryByText('common.archive')).not.toBeInTheDocument();
+  });
+});