@tuturuuu/ui 0.6.2 → 0.8.0

package/src/components/ui/tu-do/boards/__tests__/workspace-projects-client-page.test.tsx

@@ -3,7 +3,7 @@
  */
 
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { render, screen } from '@testing-library/react';
+import { render, screen, waitFor } from '@testing-library/react';
 import type { ReactNode } from 'react';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import WorkspaceProjectsClientPage from '../workspace-projects-client-page';
@@ -97,4 +97,73 @@ describe('WorkspaceProjectsClientPage', () => {
     expect(await screen.findByTestId('boards-view')).toBeInTheDocument();
     expect(mocks.replace).not.toHaveBeenCalled();
   });
+
+  it('does not fetch board data for members without manage_projects', async () => {
+    mocks.checkWorkspacePermission.mockResolvedValue({
+      hasPermission: false,
+    });
+
+    const queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+        mutations: { retry: false },
+      },
+    });
+
+    render(
+      <QueryClientProvider client={queryClient}>
+        <WorkspaceProjectsClientPage />
+      </QueryClientProvider>
+    );
+
+    await waitFor(() => {
+      expect(mocks.replace).toHaveBeenCalledWith('/personal');
+    });
+    expect(mocks.getWorkspaceBoardsData).not.toHaveBeenCalled();
+  });
+
+  it('allows task-board guests to fetch their shared boards', async () => {
+    mocks.getWorkspace.mockResolvedValue({
+      access_type: 'guest',
+      guest_products: ['tasks'],
+      id: 'guest-ws',
+      personal: false,
+    });
+    mocks.checkWorkspacePermission.mockResolvedValue({
+      hasPermission: false,
+    });
+    mocks.getWorkspaceBoardsData.mockResolvedValue({
+      access_type: 'guest',
+      count: 1,
+      data: [
+        {
+          archived_at: null,
+          deleted_at: null,
+          id: 'board-1',
+          name: 'Shared Tasks',
+        },
+      ],
+    });
+
+    const queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+        mutations: { retry: false },
+      },
+    });
+
+    render(
+      <QueryClientProvider client={queryClient}>
+        <WorkspaceProjectsClientPage />
+      </QueryClientProvider>
+    );
+
+    expect(await screen.findByTestId('boards-view')).toBeInTheDocument();
+    expect(mocks.getWorkspaceBoardsData).toHaveBeenCalledWith('guest-ws', {
+      page: 1,
+      pageSize: 10,
+      q: '',
+    });
+    expect(mocks.replace).not.toHaveBeenCalled();
+  });
 });

package/src/components/ui/tu-do/boards/boardId/board-column-external-retry.test.tsx

@@ -0,0 +1,127 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { act, render, waitFor } from '@testing-library/react';
+import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ListPaginationState } from '../../shared/progressive-loader-context';
+import { BoardColumn } from './board-column';
+
+const mocks = vi.hoisted(() => ({
+  createTask: vi.fn(),
+  loadListPage: vi.fn(),
+  pagination: {} as Record<string, ListPaginationState>,
+}));
+
+vi.mock('@dnd-kit/sortable', () => ({
+  useSortable: () => ({
+    attributes: {},
+    isDragging: false,
+    listeners: {},
+    setNodeRef: vi.fn(),
+    transform: null,
+    transition: null,
+  }),
+}));
+
+vi.mock('@dnd-kit/utilities', () => ({
+  CSS: {
+    Transform: {
+      toString: () => '',
+    },
+  },
+}));
+
+vi.mock('next-intl', () => ({
+  useTranslations: () => (key: string, values?: Record<string, string>) =>
+    values?.name ? `${key}:${values.name}` : key,
+}));
+
+vi.mock('../../hooks/useTaskDialog', () => ({
+  useTaskDialog: () => ({
+    createTask: mocks.createTask,
+  }),
+}));
+
+vi.mock('../../shared/progressive-loader-context', () => ({
+  useProgressiveLoader: () => ({
+    loadListPage: mocks.loadListPage,
+    pagination: mocks.pagination,
+    revalidateLoadedLists: vi.fn(),
+  }),
+}));
+
+vi.mock('./list-actions', () => ({
+  ListActions: () => <div data-testid="list-actions" />,
+}));
+
+vi.mock('./task-list', () => ({
+  VirtualizedTaskList: () => <div data-testid="task-list" />,
+}));
+
+const externalColumn: TaskList = {
+  archived: false,
+  board_id: 'board-1',
+  color: 'CYAN',
+  created_at: '2026-06-16T00:00:00.000Z',
+  creator_id: 'user-1',
+  deleted: false,
+  id: 'personal-external-staging:board-1',
+  is_external_staging: true,
+  name: 'External tasks',
+  position: 0,
+  status: 'active',
+};
+
+const loadedExternalState: ListPaginationState = {
+  hasMore: true,
+  isInitialLoad: false,
+  isLoading: false,
+  page: 0,
+  totalCount: 0,
+};
+
+function renderExternalColumn() {
+  return (
+    <BoardColumn
+      boardId="board-1"
+      column={externalColumn}
+      tasks={[]}
+      wsId="personal"
+    />
+  );
+}
+
+describe('BoardColumn external lane retry behavior', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.pagination = {
+      [externalColumn.id]: loadedExternalState,
+    };
+    mocks.loadListPage.mockRejectedValue(
+      new Error('external lane unavailable')
+    );
+  });
+
+  it('does not immediately retry the same failed external-options signature', async () => {
+    const { rerender } = render(renderExternalColumn());
+
+    await waitFor(() => {
+      expect(mocks.loadListPage).toHaveBeenCalledTimes(1);
+    });
+
+    await act(async () => {
+      await Promise.resolve();
+      rerender(renderExternalColumn());
+      await Promise.resolve();
+    });
+
+    expect(mocks.loadListPage).toHaveBeenCalledTimes(1);
+    expect(mocks.loadListPage).toHaveBeenCalledWith(externalColumn.id, 0, {
+      externalIncludeDocuments: false,
+      externalIncludeDoneClosed: false,
+      externalSortBy: 'created-desc',
+    });
+  });
+});

package/src/components/ui/tu-do/boards/boardId/board-column.tsx

@@ -259,9 +259,7 @@ export function BoardColumn({
       loadedExternalOptionsSignatureRef.current = externalOptionsSignature;
       const promise = loadListPage(column.id, page, externalLoadOptions);
 
-      promise.catch(() => {
-        loadedExternalOptionsSignatureRef.current = null;
-      });
+      void promise.catch(() => {});
 
       return promise;
     },

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/task-drag-cache.ts

@@ -263,6 +263,7 @@ export function applyTaskDropPreviewToCache({
   }
 
   return {
+    localMutationAt,
     previousFullTasks: snapshot.fullTasks,
     previousTasks: snapshot.tasks,
     previewSortKey: previewTasks.previewSortKey,
@@ -270,6 +271,18 @@ export function applyTaskDropPreviewToCache({
   };
 }
 
+export function hasTaskLocalMutationAt(
+  tasks: Task[] | undefined,
+  taskId: string,
+  localMutationAt: number
+) {
+  const task = tasks?.find((item) => item.id === taskId) as
+    | (Task & { _localMutationAt?: unknown })
+    | undefined;
+
+  return task?._localMutationAt === localMutationAt;
+}
+
 export function mergeTaskIntoBoardTaskCache(
   currentTasks: Task[] | undefined,
   nextTask: Task

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/use-kanban-dnd.test.ts

@@ -1,13 +1,16 @@
+import { QueryClient } from '@tanstack/react-query';
 import type { Task } from '@tuturuuu/types/primitives/Task';
 import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
 import { describe, expect, it } from 'vitest';
 import {
+  applyTaskDropPreviewToCache,
   getProjectedTaskDropOrderFromPreview,
   getTaskDropEndPreviewFromRects,
   getTaskDropPositionFromRects,
   getTaskDropPreviewCacheTasks,
   getTaskDropPreviewFromRects,
   getTaskInsertionIndex,
+  hasTaskLocalMutationAt,
   insertTaskAtDropPosition,
   mergePersonalPlacementMutationTask,
   mergeTaskIntoBoardTaskCache,
@@ -683,4 +686,64 @@ describe('task drag insertion helpers', () => {
       })
     );
   });
+
+  it('marks optimistic previews so stale drag rollbacks can be skipped', () => {
+    const queryClient = new QueryClient();
+    const boardId = 'board-1';
+    const activeTask = createTask({
+      id: 'task-1',
+      list_id: 'source-list',
+      sort_key: 1_000_000,
+    });
+    const targetTask = createTask({
+      id: 'task-2',
+      list_id: 'target-list',
+      sort_key: 2_000_000,
+    });
+    const snapshot = {
+      fullTasks: [activeTask, targetTask],
+      tasks: [activeTask, targetTask],
+    };
+
+    queryClient.setQueryData(['tasks', boardId], snapshot.tasks);
+    queryClient.setQueryData(['tasks-full', boardId], snapshot.fullTasks);
+
+    const preview = applyTaskDropPreviewToCache({
+      activeTask,
+      boardId,
+      orderedTasks: [targetTask, activeTask],
+      queryClient,
+      snapshot,
+      targetList: createList({ id: 'target-list' }),
+      targetListId: 'target-list',
+    });
+
+    expect(preview?.localMutationAt).toEqual(expect.any(Number));
+    expect(
+      hasTaskLocalMutationAt(
+        queryClient.getQueryData<Task[]>(['tasks', boardId]),
+        activeTask.id,
+        preview?.localMutationAt ?? -1
+      )
+    ).toBe(true);
+
+    queryClient.setQueryData<Task[]>(['tasks', boardId], (currentTasks) =>
+      currentTasks?.map((task) =>
+        task.id === activeTask.id
+          ? ({
+              ...task,
+              _localMutationAt: (preview?.localMutationAt ?? 0) + 1,
+            } as Task & { _localMutationAt: number })
+          : task
+      )
+    );
+
+    expect(
+      hasTaskLocalMutationAt(
+        queryClient.getQueryData<Task[]>(['tasks', boardId]),
+        activeTask.id,
+        preview?.localMutationAt ?? -1
+      )
+    ).toBe(false);
+  });
 });

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/use-kanban-dnd.ts

@@ -28,6 +28,7 @@ import { getColumnReorderUpdates } from './column-reorder';
 import { calculateSortKeyWithRetry as createCalculateSortKeyWithRetry } from './kanban-sort-helpers';
 import {
   applyTaskDropPreviewToCache,
+  hasTaskLocalMutationAt,
   mergePersonalPlacementMutationTask,
   setBoardTaskCache,
 } from './task-drag-cache';
@@ -65,6 +66,7 @@ import type {
 export {
   applyTaskDropPreviewToCache,
   getTaskDropPreviewCacheTasks,
+  hasTaskLocalMutationAt,
   mergePersonalPlacementMutationTask,
   mergeTaskIntoBoardTaskCache,
 } from './task-drag-cache';
@@ -504,6 +506,16 @@ export function useKanbanDnd({
           queryClient.setQueryData<Task[]>(queryKey, (currentTasks) => {
             if (!currentTasks) return previousCache;
 
+            if (
+              !hasTaskLocalMutationAt(
+                currentTasks,
+                task.id,
+                nextTask._localMutationAt
+              )
+            ) {
+              return currentTasks;
+            }
+
             if (!previousTaskValue) {
               return currentTasks.filter((item) => item.id !== task.id);
             }
@@ -1079,17 +1091,43 @@ export function useKanbanDnd({
         if (!boardId || !optimisticDropPreview) return;
 
         if (optimisticDropPreview.previousTasks) {
-          queryClient.setQueryData(
-            ['tasks', boardId],
-            optimisticDropPreview.previousTasks
-          );
+          const currentTasks = queryClient.getQueryData<Task[]>([
+            'tasks',
+            boardId,
+          ]);
+
+          if (
+            hasTaskLocalMutationAt(
+              currentTasks,
+              activeTaskForDrop.id,
+              optimisticDropPreview.localMutationAt
+            )
+          ) {
+            queryClient.setQueryData(
+              ['tasks', boardId],
+              optimisticDropPreview.previousTasks
+            );
+          }
         }
 
         if (optimisticDropPreview.previousFullTasks) {
-          queryClient.setQueryData(
-            ['tasks-full', boardId],
-            optimisticDropPreview.previousFullTasks
-          );
+          const currentFullTasks = queryClient.getQueryData<Task[]>([
+            'tasks-full',
+            boardId,
+          ]);
+
+          if (
+            hasTaskLocalMutationAt(
+              currentFullTasks,
+              activeTaskForDrop.id,
+              optimisticDropPreview.localMutationAt
+            )
+          ) {
+            queryClient.setQueryData(
+              ['tasks-full', boardId],
+              optimisticDropPreview.previousFullTasks
+            );
+          }
         }
       };
 

package/src/components/ui/tu-do/boards/boardId/kanban/rendering/kanban-columns.test.tsx

@@ -7,7 +7,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { DEFAULT_KANBAN_COLUMN_WIDTH } from './kanban-column-width';
 import { KanbanColumns } from './kanban-columns';
 
-const { taskCardMock } = vi.hoisted(() => ({
+const { cursorOverlayMock, taskCardMock } = vi.hoisted(() => ({
+  cursorOverlayMock: vi.fn(),
   taskCardMock: vi.fn(),
 }));
 
@@ -41,7 +42,10 @@ vi.mock('../../task', () => ({
 }));
 
 vi.mock('../../../../shared/cursor-overlay-multi-wrapper', () => ({
-  default: () => <div data-testid="cursor-overlay" />,
+  default: (props: Record<string, unknown>) => {
+    cursorOverlayMock(props);
+    return <div data-testid="cursor-overlay" />;
+  },
 }));
 
 const lists: TaskList[] = [
@@ -112,6 +116,7 @@ function task(overrides: Partial<Task>): Task {
 
 describe('KanbanColumns', () => {
   beforeEach(() => {
+    cursorOverlayMock.mockClear();
     taskCardMock.mockClear();
   });
 
@@ -263,6 +268,12 @@ describe('KanbanColumns', () => {
     );
 
     expect(screen.getByTestId('cursor-overlay')).toBeInTheDocument();
+    expect(cursorOverlayMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        channelName: 'board-realtime-board-1',
+        cursorScope: { boardId: 'board-1', type: 'board' },
+      })
+    );
   });
 
   it('renders populated deadline panels before the regular kanban columns', () => {

package/src/components/ui/tu-do/boards/boardId/kanban/rendering/kanban-columns.tsx

@@ -6,6 +6,7 @@ import {
 } from '@dnd-kit/sortable';
 import type { Task } from '@tuturuuu/types/primitives/Task';
 import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
+import { getBoardRealtimeChannelName } from '@tuturuuu/ui/hooks/useBoardRealtime.types';
 import type { ListStatusFilter } from '../../../../shared/board-header';
 import CursorOverlayMultiWrapper from '../../../../shared/cursor-overlay-multi-wrapper';
 import { BoardColumn } from '../../board-column';
@@ -219,8 +220,9 @@ export function KanbanColumns({
       {/* Overlay for collaborator cursors (gated on tier — free workspaces don't get board cursors) */}
       {!isPersonalWorkspace && boardId && cursorsEnabled && (
         <CursorOverlayMultiWrapper
-          channelName={`board-cursor-${boardId}`}
+          channelName={getBoardRealtimeChannelName(boardId)}
           containerRef={boardRef}
+          cursorScope={{ boardId, type: 'board' }}
           listStatusFilter={listStatusFilter}
           filters={filters}
         />

package/src/components/ui/tu-do/boards/boardId/task-board-server-page.test.tsx

@@ -0,0 +1,164 @@
+import type { ReactElement } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => {
+  class MockInternalApiError extends Error {
+    constructor(
+      message: string,
+      public readonly status: number,
+      public readonly code?: string
+    ) {
+      super(message);
+      this.name = 'InternalApiError';
+    }
+  }
+
+  return {
+    BoardClient: vi.fn(),
+    getCurrentUser: vi.fn(),
+    getWorkspace: vi.fn(),
+    getWorkspaceTaskBoard: vi.fn(),
+    headers: vi.fn(),
+    InternalApiError: MockInternalApiError,
+    notFound: vi.fn(() => {
+      throw new Error('NEXT_NOT_FOUND');
+    }),
+    redirect: vi.fn((url: string) => {
+      throw new Error(`NEXT_REDIRECT:${url}`);
+    }),
+    withForwardedInternalApiAuth: vi.fn(() => ({ auth: 'forwarded' })),
+  };
+});
+
+vi.mock('@tuturuuu/ui/tu-do/shared/board-client', () => ({
+  BoardClient: mocks.BoardClient,
+}));
+
+vi.mock('@tuturuuu/internal-api', () => ({
+  getWorkspaceTaskBoard: (
+    ...args: Parameters<typeof mocks.getWorkspaceTaskBoard>
+  ) => mocks.getWorkspaceTaskBoard(...args),
+  InternalApiError: mocks.InternalApiError,
+  withForwardedInternalApiAuth: (
+    ...args: Parameters<typeof mocks.withForwardedInternalApiAuth>
+  ) => mocks.withForwardedInternalApiAuth(...args),
+}));
+
+vi.mock('@tuturuuu/utils/user-helper', () => ({
+  getCurrentUser: (...args: Parameters<typeof mocks.getCurrentUser>) =>
+    mocks.getCurrentUser(...args),
+}));
+
+vi.mock('@tuturuuu/utils/workspace-helper', () => ({
+  getWorkspace: (...args: Parameters<typeof mocks.getWorkspace>) =>
+    mocks.getWorkspace(...args),
+}));
+
+vi.mock('next/headers', () => ({
+  headers: (...args: Parameters<typeof mocks.headers>) =>
+    mocks.headers(...args),
+}));
+
+vi.mock('next/navigation', () => ({
+  notFound: (...args: Parameters<typeof mocks.notFound>) =>
+    mocks.notFound(...args),
+  redirect: (...args: Parameters<typeof mocks.redirect>) =>
+    mocks.redirect(...args),
+}));
+
+import TaskBoardServerPage from './task-board-server-page';
+
+const BOARD_ID = '11111111-1111-1111-1111-111111111111';
+
+type BoardClientElement = ReactElement<{
+  currentUserId?: string;
+  workspace: unknown;
+  workspaceTier: unknown;
+}>;
+
+function renderServerPage() {
+  return TaskBoardServerPage({
+    params: Promise.resolve({
+      boardId: BOARD_ID,
+      wsId: 'ws-1',
+    }),
+  }) as Promise<BoardClientElement>;
+}
+
+describe('TaskBoardServerPage', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.getCurrentUser.mockResolvedValue({
+      email: 'member@example.com',
+      id: 'user-1',
+    });
+    mocks.headers.mockResolvedValue(new Headers({ cookie: 'session=1' }));
+  });
+
+  it('checks board access before fetching workspace metadata', async () => {
+    mocks.getWorkspaceTaskBoard.mockRejectedValue(
+      new mocks.InternalApiError('Forbidden', 403)
+    );
+
+    await expect(renderServerPage()).rejects.toThrow('NEXT_NOT_FOUND');
+
+    expect(mocks.withForwardedInternalApiAuth).toHaveBeenCalledWith(
+      expect.any(Headers)
+    );
+    expect(mocks.getWorkspaceTaskBoard).toHaveBeenCalledWith('ws-1', BOARD_ID, {
+      auth: 'forwarded',
+    });
+    expect(mocks.getWorkspace).not.toHaveBeenCalled();
+  });
+
+  it('uses a minimal workspace shell for board guests', async () => {
+    mocks.getWorkspaceTaskBoard.mockResolvedValue({
+      board: {
+        access_type: 'guest',
+        id: BOARD_ID,
+        ws_id: 'ws-guest',
+      },
+    });
+
+    const element = await renderServerPage();
+
+    expect(mocks.getWorkspace).not.toHaveBeenCalled();
+    expect(element.type).toBe(mocks.BoardClient);
+    expect(element.props.workspace).toEqual({
+      id: 'ws-guest',
+      joined: false,
+      personal: false,
+      tier: null,
+    });
+    expect(element.props.workspaceTier).toBeNull();
+    expect(element.props.currentUserId).toBe('user-1');
+  });
+
+  it('loads the full member workspace only after board access succeeds', async () => {
+    const workspace = {
+      creator_id: 'creator-1',
+      id: 'ws-1',
+      joined: true,
+      name: 'Member Workspace',
+      personal: false,
+      tier: 'FREE',
+    };
+    mocks.getWorkspaceTaskBoard.mockResolvedValue({
+      board: {
+        access_type: 'member',
+        id: BOARD_ID,
+        ws_id: 'ws-1',
+      },
+    });
+    mocks.getWorkspace.mockResolvedValue(workspace);
+
+    const element = await renderServerPage();
+
+    expect(mocks.getWorkspace).toHaveBeenCalledWith('ws-1', {
+      useAdmin: true,
+    });
+    expect(element.type).toBe(mocks.BoardClient);
+    expect(element.props.workspace).toBe(workspace);
+    expect(element.props.workspaceTier).toBe('FREE');
+  });
+});