@tuturuuu/ui 0.1.0 → 0.2.0

package/src/components/ui/chat/chat-sidebar-panel.test.tsx

@@ -0,0 +1,110 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import type { ChatConversation } from '@tuturuuu/internal-api';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatSidebarPanel } from './chat-sidebar-panel';
+
+const mocks = vi.hoisted(() => ({
+  chatSidebarProps: null as Record<string, unknown> | null,
+  fetchNextPage: vi.fn(),
+  useChatMessageSearch: vi.fn(),
+  useInfiniteChatConversations: vi.fn(),
+}));
+
+vi.mock('next-intl', () => ({
+  useTranslations: () => (key: string) => key,
+}));
+
+vi.mock('next/navigation', () => ({
+  usePathname: () => '/personal',
+  useSearchParams: () => new URLSearchParams('scope=personal'),
+}));
+
+vi.mock('./chat-sidebar', () => ({
+  ChatSidebar: (props: Record<string, unknown>) => {
+    mocks.chatSidebarProps = props;
+    return (
+      <button
+        onClick={() =>
+          (props.onLoadMoreConversations as (() => void) | undefined)?.()
+        }
+        type="button"
+      >
+        load more
+      </button>
+    );
+  },
+}));
+
+vi.mock('./create-conversation-dialog', () => ({
+  CreateConversationDialog: () => null,
+}));
+
+vi.mock('./hooks', () => ({
+  flattenChatConversationPages: (
+    data?: { pages?: { conversations?: ChatConversation[] }[] } | null
+  ) => data?.pages?.flatMap((page) => page.conversations ?? []) ?? [],
+  useChatMessageSearch: (...args: unknown[]) =>
+    mocks.useChatMessageSearch(...args),
+  useInfiniteChatConversations: (...args: unknown[]) =>
+    mocks.useInfiniteChatConversations(...args),
+}));
+
+const conversation: ChatConversation = {
+  aiEnabled: false,
+  archivedAt: null,
+  createdAt: '2026-06-02T00:00:00.000Z',
+  createdBy: 'user-1',
+  description: null,
+  id: 'conversation-1',
+  latestMessage: null,
+  memberCount: 2,
+  members: [],
+  metadata: {},
+  title: 'Planning',
+  type: 'group',
+  unreadCount: 0,
+  updatedAt: '2026-06-02T00:00:00.000Z',
+  wsId: 'personal',
+};
+
+describe('ChatSidebarPanel', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.chatSidebarProps = null;
+    mocks.useChatMessageSearch.mockReturnValue({ data: [] });
+    mocks.useInfiniteChatConversations.mockReturnValue({
+      data: {
+        pages: [{ conversations: [conversation], nextOffset: 40 }],
+      },
+      fetchNextPage: mocks.fetchNextPage,
+      hasNextPage: true,
+      isFetchingNextPage: false,
+      isLoading: false,
+    });
+  });
+
+  it('uses the infinite conversations query and forwards load-more controls', () => {
+    render(
+      <ChatSidebarPanel
+        currentUserId="user-1"
+        isCollapsed={false}
+        wsId="personal"
+      />
+    );
+
+    expect(mocks.useInfiniteChatConversations).toHaveBeenCalledWith({
+      archived: 'active',
+      wsId: 'personal',
+    });
+    expect(mocks.chatSidebarProps).toMatchObject({
+      conversations: [conversation],
+      hasMoreConversations: true,
+      isFetchingMoreConversations: false,
+      isLoading: false,
+    });
+
+    fireEvent.click(screen.getByRole('button', { name: 'load more' }));
+
+    expect(mocks.fetchNextPage).toHaveBeenCalledTimes(1);
+  });
+});

package/src/components/ui/chat/chat-sidebar-panel.tsx

@@ -3,7 +3,11 @@ import { usePathname, useSearchParams } from 'next/navigation';
 import { useEffect, useState } from 'react';
 import { ChatSidebar } from './chat-sidebar';
 import { CreateConversationDialog } from './create-conversation-dialog';
-import { useChatConversations, useChatMessageSearch } from './hooks';
+import {
+  flattenChatConversationPages,
+  useChatMessageSearch,
+  useInfiniteChatConversations,
+} from './hooks';
 import {
   CHAT_CONVERSATION_TYPE_FILTERS,
   type ChatConversationArchiveFilter,
@@ -62,7 +66,10 @@ export function ChatSidebarPanel({
   const setCreateOpen = onCreateOpenChange ?? setInternalCreateOpen;
   const archiveFilter = controlledArchiveFilter ?? internalArchiveFilter;
   const selectedTypes = controlledSelectedTypes ?? internalSelectedTypes;
-  const conversationsQuery = useChatConversations(wsId, archiveFilter);
+  const conversationsQuery = useInfiniteChatConversations({
+    archived: archiveFilter,
+    wsId,
+  });
   const searchQuery = useChatMessageSearch({
     query: searchValue,
     wsId,
@@ -70,7 +77,7 @@ export function ChatSidebarPanel({
   const conversationScope = normalizeChatConversationScope(
     searchParams.get('scope') ?? defaultConversationScope
   );
-  const conversations = conversationsQuery.data ?? [];
+  const conversations = flattenChatConversationPages(conversationsQuery.data);
   const scopeConversations = filterChatConversationsByScope(
     conversations,
     conversationScope
@@ -158,7 +165,10 @@ export function ChatSidebarPanel({
         conversations={scopedConversations}
         currentUserId={currentUserId}
         embedded
+        hasMoreConversations={conversationsQuery.hasNextPage}
+        isFetchingMoreConversations={conversationsQuery.isFetchingNextPage}
         isLoading={conversationsQuery.isLoading}
+        onLoadMoreConversations={() => conversationsQuery.fetchNextPage()}
         onSearchChange={setSearchValue}
         onSelectConversation={selectConversation}
         searchResults={scopedSearchResults}

package/src/components/ui/legacy/meet/planId/page.tsx

@@ -17,23 +17,29 @@ interface Props {
   params: Promise<{
     planId: string;
   }>;
+  actorUserId?: string | null;
   baseUrl: string;
 }
 
 export default async function MeetTogetherPlanDetailsPage({
+  actorUserId,
   params,
   baseUrl,
 }: Props) {
   const { planId } = await params;
 
   const platformUser = await getCurrentUser();
-  const plan = await getPlan(planId);
-  const users: PlanUser[] = await getUsers(planId);
-  const polls = await getPollsForPlan(planId);
-  const timeblocks = await getTimeBlocks(planId);
+  const plan = await getPlan(planId, { actorUserId });
 
   if (!plan) return notFound();
 
+  const canonicalPlanId = plan.id;
+  if (!canonicalPlanId) return notFound();
+
+  const users: PlanUser[] = await getUsers(canonicalPlanId);
+  const polls = await getPollsForPlan(canonicalPlanId);
+  const timeblocks = await getTimeBlocks(canonicalPlanId);
+
   return (
     <div className="flex min-h-screen w-full flex-col items-center">
       <Suspense fallback={null}>

package/src/components/ui/text-editor/__tests__/task-mention-chip.test.tsx

@@ -102,15 +102,20 @@ vi.mock('../../sonner', () => ({
   },
 }));
 
-function renderWithQueryClient(children: ReactNode) {
-  const queryClient = new QueryClient({
+function createTestQueryClient() {
+  return new QueryClient({
     defaultOptions: {
       queries: {
         retry: false,
       },
     },
   });
+}
 
+function renderWithQueryClient(
+  children: ReactNode,
+  queryClient = createTestQueryClient()
+) {
   return render(
     <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
   );
@@ -217,7 +222,112 @@ describe('TaskMentionChip', () => {
     expect(screen.getByText('Complete Team Charter V1.0')).toBeInTheDocument();
   });
 
-  it('uses the mention workspace when repairing a task from another workspace', async () => {
+  it('does not reuse stale mention fallback cache across board contexts', async () => {
+    const boardOneTask = {
+      assignees: [],
+      board_id: 'board-1',
+      display_number: 3,
+      id: 'board-one-task-id',
+      labels: [],
+      list_id: 'list-1',
+      name: 'Board one task',
+      projects: [],
+      ticket_prefix: null,
+    };
+    const boardTwoTask = {
+      assignees: [],
+      board_id: 'board-2',
+      display_number: 4,
+      id: 'board-two-task-id',
+      labels: [],
+      list_id: 'list-2',
+      name: 'Board two task',
+      projects: [],
+      ticket_prefix: null,
+    };
+    const queryClient = createTestQueryClient();
+    const firstResolved = vi.fn();
+    const secondResolved = vi.fn();
+
+    mocks.getCurrentUserTask.mockImplementation(async (taskId: string) => {
+      if (taskId === 'stale-task-id') {
+        throw new Error('Task not found');
+      }
+
+      const task =
+        taskId === boardOneTask.id
+          ? boardOneTask
+          : taskId === boardTwoTask.id
+            ? boardTwoTask
+            : null;
+
+      if (!task) {
+        throw new Error('Task not found');
+      }
+
+      return {
+        availableLists: [],
+        task,
+        taskWorkspacePersonal: false,
+        taskWorkspaceTier: 'FREE',
+        taskWsId: 'ws-1',
+      };
+    });
+    mocks.listWorkspaceTasks.mockImplementation(
+      async (_wsId: string, params: { boardId?: string }) => ({
+        tasks: params.boardId === 'board-2' ? [boardTwoTask] : [boardOneTask],
+      })
+    );
+
+    const firstRender = renderWithQueryClient(
+      <TaskMentionChip
+        entityId="stale-task-id"
+        displayNumber="3"
+        subtitle="Board one task"
+        onResolvedTaskMention={firstResolved}
+      />,
+      queryClient
+    );
+
+    await waitFor(() => {
+      expect(firstResolved).toHaveBeenCalledWith(
+        expect.objectContaining({ entityId: boardOneTask.id })
+      );
+    });
+
+    firstRender.unmount();
+    window.history.pushState({}, '', '/ws-1/tasks/boards/board-2');
+
+    renderWithQueryClient(
+      <TaskMentionChip
+        entityId="stale-task-id"
+        displayNumber="4"
+        subtitle="Board two task"
+        onResolvedTaskMention={secondResolved}
+      />,
+      queryClient
+    );
+
+    await waitFor(() => {
+      expect(mocks.listWorkspaceTasks).toHaveBeenCalledWith(
+        'ws-1',
+        expect.objectContaining({
+          boardId: 'board-2',
+          identifier: '4',
+        })
+      );
+    });
+    await waitFor(() => {
+      expect(secondResolved).toHaveBeenCalledWith(
+        expect.objectContaining({ entityId: boardTwoTask.id })
+      );
+    });
+    expect(secondResolved).not.toHaveBeenCalledWith(
+      expect.objectContaining({ entityId: boardOneTask.id })
+    );
+  });
+
+  it('ignores untrusted mention workspace when repairing stale task mentions', async () => {
     const resolvedTask = {
       assignees: [],
       board_id: 'board-1',
@@ -242,7 +352,7 @@ describe('TaskMentionChip', () => {
         task: resolvedTask,
         taskWorkspacePersonal: false,
         taskWorkspaceTier: 'FREE',
-        taskWsId: 'source-ws',
+        taskWsId: 'route-ws',
       };
     });
     mocks.listWorkspaceTasks.mockResolvedValue({ tasks: [resolvedTask] });
@@ -259,7 +369,7 @@ describe('TaskMentionChip', () => {
 
     await waitFor(() => {
       expect(mocks.listWorkspaceTasks).toHaveBeenCalledWith(
-        'source-ws',
+        'route-ws',
         expect.objectContaining({
           boardId: 'board-1',
           identifier: '7',
@@ -271,9 +381,96 @@ describe('TaskMentionChip', () => {
       expect(onResolvedTaskMention).toHaveBeenCalledWith(
         expect.objectContaining({
           entityId: 'source-task-id',
-          workspaceId: 'source-ws',
+          workspaceId: 'route-ws',
         })
       );
     });
   });
+
+  it('does not rewrite stale mentions to tasks from another workspace', async () => {
+    const resolvedTask = {
+      assignees: [],
+      board_id: 'board-1',
+      display_number: 8,
+      id: 'source-task-id',
+      labels: [],
+      list_id: 'list-1',
+      name: 'Source workspace task',
+      projects: [],
+      ticket_prefix: null,
+    };
+    const onResolvedTaskMention = vi.fn();
+
+    window.history.pushState({}, '', '/route-ws/tasks/boards/board-1');
+    mocks.getCurrentUserTask.mockImplementation(async (taskId: string) => {
+      if (taskId === 'stale-task-id') {
+        throw new Error('Task not found');
+      }
+
+      return {
+        availableLists: [],
+        task: resolvedTask,
+        taskWorkspacePersonal: false,
+        taskWorkspaceTier: 'FREE',
+        taskWsId: 'source-ws',
+      };
+    });
+    mocks.listWorkspaceTasks.mockResolvedValue({ tasks: [resolvedTask] });
+
+    renderWithQueryClient(
+      <TaskMentionChip
+        entityId="stale-task-id"
+        displayNumber="8"
+        subtitle="Source workspace task"
+        onResolvedTaskMention={onResolvedTaskMention}
+      />
+    );
+
+    await waitFor(() => {
+      expect(mocks.getCurrentUserTask).toHaveBeenCalledWith('source-task-id');
+    });
+
+    expect(onResolvedTaskMention).not.toHaveBeenCalled();
+  });
+
+  it('uses the server-returned workspace for resolved cross-workspace task mentions', async () => {
+    const resolvedTask = {
+      assignees: [],
+      board_id: 'source-board',
+      display_number: 9,
+      id: 'source-task-id',
+      labels: [],
+      list_id: 'list-1',
+      name: 'Trusted cross workspace task',
+      projects: [],
+      ticket_prefix: null,
+    };
+
+    window.history.pushState({}, '', '/route-ws/tasks/boards/board-1');
+    mocks.getCurrentUserTask.mockResolvedValue({
+      availableLists: [],
+      task: resolvedTask,
+      taskWorkspacePersonal: false,
+      taskWorkspaceTier: 'FREE',
+      taskWsId: 'source-ws',
+    });
+
+    renderWithQueryClient(
+      <TaskMentionChip
+        entityId="source-task-id"
+        displayNumber="9"
+        subtitle="Trusted cross workspace task"
+        workspaceId="source-ws"
+      />
+    );
+
+    await waitFor(() => {
+      expect(mocks.getCurrentUserTask).toHaveBeenCalledWith('source-task-id');
+    });
+
+    expect(mocks.listWorkspaceTasks).not.toHaveBeenCalled();
+    expect(
+      screen.getByText('Trusted cross workspace task')
+    ).toBeInTheDocument();
+  });
 });

package/src/components/ui/text-editor/task-mention-chip.tsx

@@ -186,7 +186,6 @@ export function TaskMentionChip({
   displayNumber,
   avatarUrl,
   subtitle,
-  workspaceId,
   className,
   editor: editorProp,
   onResolvedTaskMention,
@@ -213,8 +212,19 @@ export function TaskMentionChip({
 
     return getRouteTaskBoardIdFromPathname(window.location.pathname);
   }, []);
-  const mentionWorkspaceId = workspaceId?.trim() || undefined;
-  const resolutionWorkspaceId = mentionWorkspaceId ?? routeWsId;
+  const resolutionWorkspaceId = routeWsId;
+  const taskMentionQueryKey = useMemo(
+    () => [
+      'task',
+      'mention',
+      entityId,
+      resolutionWorkspaceId ?? null,
+      routeBoardId ?? null,
+      displayNumber.trim(),
+      subtitle?.trim() ?? null,
+    ],
+    [displayNumber, entityId, resolutionWorkspaceId, routeBoardId, subtitle]
+  );
   const isDark = useDomResolvedTheme() === 'dark';
 
   // Dialog states
@@ -230,7 +240,7 @@ export function TaskMentionChip({
     isLoading: taskLoading,
     error: taskError,
   } = useQuery({
-    queryKey: ['task', entityId, resolutionWorkspaceId],
+    queryKey: taskMentionQueryKey,
     queryFn: async () => {
       return resolveTaskMentionPayload({
         displayNumber,
@@ -249,9 +259,19 @@ export function TaskMentionChip({
   const resolvedTaskId = task?.id ?? entityId;
   const taskWorkspaceId = taskPayload?.taskWsId;
   const taskWorkspacePersonal = taskPayload?.taskWorkspacePersonal;
-  const canonicalWorkspaceId =
-    mentionWorkspaceId ?? taskWorkspaceId ?? routeWsId;
+  const canonicalWorkspaceId = taskWorkspaceId ?? routeWsId;
   const boardWorkspaceId = canonicalWorkspaceId;
+  const resolvedTaskBelongsToRouteWorkspace = useMemo(() => {
+    if (!routeWsId || !taskWorkspaceId) {
+      return false;
+    }
+
+    if (taskWorkspaceId === routeWsId) {
+      return true;
+    }
+
+    return routeWsId === 'personal' && taskWorkspacePersonal === true;
+  }, [routeWsId, taskWorkspaceId, taskWorkspacePersonal]);
 
   // Get board config - only fetch when menu opens and we have task data
   const { data: boardConfig } = useBoardConfig(
@@ -394,6 +414,7 @@ export function TaskMentionChip({
   }, [availableLists, task]);
 
   const handleUpdate = useCallback(() => {
+    queryClient.invalidateQueries({ queryKey: ['task', 'mention'] });
     queryClient.invalidateQueries({ queryKey: ['task', entityId] });
     if (resolvedTaskId !== entityId) {
       queryClient.invalidateQueries({ queryKey: ['task', resolvedTaskId] });
@@ -668,7 +689,7 @@ export function TaskMentionChip({
   }, [task?.name, subtitle]);
 
   useEffect(() => {
-    if (!task || task.id === entityId) {
+    if (!task || task.id === entityId || !resolvedTaskBelongsToRouteWorkspace) {
       return;
     }
 
@@ -697,6 +718,7 @@ export function TaskMentionChip({
     entityId,
     onResolvedTaskMention,
     queryClient,
+    resolvedTaskBelongsToRouteWorkspace,
     subtitle,
     task,
     taskPayload,

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

@@ -90,29 +90,48 @@ describe('useTaskRealtimeSync', () => {
     );
   });
 
-  it('applies a matching task upsert to the open dialog state', () => {
+  it('refetches a matching task upsert before applying open dialog state', async () => {
     const start = '2026-05-22T01:00:00.000Z';
     const end = '2026-05-22T02:00:00.000Z';
     const props = makeProps();
 
+    taskApiMocks.getWorkspaceTask.mockResolvedValueOnce({
+      task: {
+        id: 'task-1',
+        name: 'Server task',
+        priority: 'high',
+        start_date: start,
+        end_date: end,
+        estimation_points: 5,
+        list_id: 'list-2',
+      },
+    });
+
     renderHook(() => useTaskRealtimeSync(props), { wrapper });
 
     act(() => {
       boardRealtimeMocks.onTaskChange?.(
         {
           id: 'task-1',
-          name: 'Remote task',
-          priority: 'high',
-          start_date: start,
-          end_date: end,
-          estimation_points: 5,
-          list_id: 'list-2',
+          name: 'Untrusted broadcast task',
+          priority: 'critical',
+          start_date: '2026-05-23T01:00:00.000Z',
+          end_date: '2026-05-23T02:00:00.000Z',
+          estimation_points: 8,
+          list_id: 'list-3',
         } as Task,
         'UPDATE'
       );
     });
 
-    expect(props.setName).toHaveBeenCalledWith('Remote task');
+    await waitFor(() => {
+      expect(props.setName).toHaveBeenCalledWith('Server task');
+    });
+    expect(taskApiMocks.getWorkspaceTask).toHaveBeenCalledWith(
+      'ws-1',
+      'task-1'
+    );
+    expect(props.setName).not.toHaveBeenCalledWith('Untrusted broadcast task');
     expect(props.setPriority).toHaveBeenCalledWith('high');
     expect(props.setStartDate).toHaveBeenCalledWith(new Date(start));
     expect(props.setEndDate).toHaveBeenCalledWith(new Date(end));
@@ -137,10 +156,13 @@ describe('useTaskRealtimeSync', () => {
     expect(props.setSelectedListId).not.toHaveBeenCalled();
   });
 
-  it('does not overwrite a local pending title edit', () => {
+  it('does not overwrite a local pending title edit', async () => {
     const props = makeProps({
       pendingNameRef: { current: 'Local draft title' },
     });
+    taskApiMocks.getWorkspaceTask.mockResolvedValueOnce({
+      task: { id: 'task-1', name: 'Remote title' },
+    });
 
     renderHook(() => useTaskRealtimeSync(props), { wrapper });
 
@@ -151,6 +173,12 @@ describe('useTaskRealtimeSync', () => {
       );
     });
 
+    await waitFor(() => {
+      expect(taskApiMocks.getWorkspaceTask).toHaveBeenCalledWith(
+        'ws-1',
+        'task-1'
+      );
+    });
     expect(props.setName).not.toHaveBeenCalled();
   });