@tuturuuu/ui 0.9.0 → 0.11.0

package/src/components/ui/tu-do/shared/task-edit-dialog/description-versions.ts

@@ -0,0 +1,210 @@
+import type { JSONContent } from '@tiptap/react';
+import {
+  getDescriptionContent,
+  getTaskDescriptionPreviewText,
+  normalizeTaskDescriptionSnapshot,
+  serializeTaskDescriptionPersistenceSnapshot,
+} from './utils';
+
+export interface TaskDescriptionHistoryUser {
+  id: string;
+  name: string;
+  avatar_url?: string | null;
+}
+
+export interface TaskDescriptionHistoryEntryLike {
+  id: string;
+  changed_at: string;
+  change_type?: string | null;
+  field_name?: string | null;
+  old_value?: unknown;
+  new_value?: unknown;
+  user?: TaskDescriptionHistoryUser | null;
+}
+
+export type TaskDescriptionVersionSource = 'new_value' | 'old_value';
+export type TaskDescriptionVersionReason = 'before_clear' | 'tracked';
+
+export interface RecoverableTaskDescriptionVersion {
+  id: string;
+  historyId: string;
+  changedAt: string;
+  source: TaskDescriptionVersionSource;
+  reason: TaskDescriptionVersionReason;
+  description: string;
+  content: JSONContent;
+  previewText: string;
+  user: TaskDescriptionHistoryUser | null;
+}
+
+const LEGACY_DESCRIPTION_PLACEHOLDERS = new Set(['has_content']);
+
+function isLegacyDescriptionPlaceholder(value: string) {
+  return LEGACY_DESCRIPTION_PLACEHOLDERS.has(value.trim().toLowerCase());
+}
+
+function hasObjectShape(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function textToDescriptionContent(text: string): JSONContent {
+  return {
+    type: 'doc',
+    content: [
+      {
+        type: 'paragraph',
+        content: [{ type: 'text', text }],
+      },
+    ],
+  };
+}
+
+function coerceDescriptionValueToContent(value: unknown): JSONContent | null {
+  if (value === null || value === undefined) return null;
+
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (!trimmed || isLegacyDescriptionPlaceholder(trimmed)) return null;
+
+    try {
+      const parsed = JSON.parse(trimmed) as unknown;
+
+      if (typeof parsed === 'string') {
+        const parsedText = parsed.trim();
+        if (!parsedText || isLegacyDescriptionPlaceholder(parsedText)) {
+          return null;
+        }
+        return textToDescriptionContent(parsed);
+      }
+
+      if (hasObjectShape(parsed)) {
+        return getDescriptionContent(parsed);
+      }
+
+      return null;
+    } catch {
+      return textToDescriptionContent(value);
+    }
+  }
+
+  if (hasObjectShape(value)) {
+    return getDescriptionContent(value);
+  }
+
+  return null;
+}
+
+export function extractRecoverableTaskDescriptionValue(value: unknown): {
+  content: JSONContent;
+  description: string;
+  previewText: string;
+} | null {
+  const content = normalizeTaskDescriptionSnapshot(
+    coerceDescriptionValueToContent(value)
+  );
+  if (!content) return null;
+
+  const description = serializeTaskDescriptionPersistenceSnapshot(content);
+  if (!description) return null;
+
+  return {
+    content,
+    description,
+    previewText: getTaskDescriptionPreviewText(content).trim(),
+  };
+}
+
+export function isTaskDescriptionHistoryEntry(
+  entry: TaskDescriptionHistoryEntryLike
+) {
+  return (
+    entry.change_type === 'field_updated' && entry.field_name === 'description'
+  );
+}
+
+export function isTaskDescriptionHistoryValueEmpty(value: unknown) {
+  return extractRecoverableTaskDescriptionValue(value) === null;
+}
+
+function addDescriptionVersion({
+  entry,
+  reason,
+  seenDescriptions,
+  source,
+  value,
+  versions,
+}: {
+  entry: TaskDescriptionHistoryEntryLike;
+  reason: TaskDescriptionVersionReason;
+  seenDescriptions: Set<string>;
+  source: TaskDescriptionVersionSource;
+  value: unknown;
+  versions: RecoverableTaskDescriptionVersion[];
+}) {
+  const recoverableValue = extractRecoverableTaskDescriptionValue(value);
+  if (!recoverableValue) return;
+  if (seenDescriptions.has(recoverableValue.description)) return;
+
+  seenDescriptions.add(recoverableValue.description);
+  versions.push({
+    id: `${entry.id}:${source}`,
+    historyId: entry.id,
+    changedAt: entry.changed_at,
+    source,
+    reason,
+    description: recoverableValue.description,
+    content: recoverableValue.content,
+    previewText: recoverableValue.previewText,
+    user: entry.user ?? null,
+  });
+}
+
+export function buildRecoverableTaskDescriptionVersions(
+  entries: TaskDescriptionHistoryEntryLike[]
+) {
+  const versions: RecoverableTaskDescriptionVersion[] = [];
+  const seenDescriptions = new Set<string>();
+  const sortedEntries = [...entries]
+    .filter(isTaskDescriptionHistoryEntry)
+    .sort(
+      (a, b) =>
+        new Date(b.changed_at).getTime() - new Date(a.changed_at).getTime()
+    );
+
+  for (const entry of sortedEntries) {
+    const oldIsRecoverable =
+      extractRecoverableTaskDescriptionValue(entry.old_value) !== null;
+    const newIsEmpty = isTaskDescriptionHistoryValueEmpty(entry.new_value);
+
+    if (oldIsRecoverable && newIsEmpty) {
+      addDescriptionVersion({
+        entry,
+        reason: 'before_clear',
+        seenDescriptions,
+        source: 'old_value',
+        value: entry.old_value,
+        versions,
+      });
+      continue;
+    }
+
+    addDescriptionVersion({
+      entry,
+      reason: 'tracked',
+      seenDescriptions,
+      source: 'new_value',
+      value: entry.new_value,
+      versions,
+    });
+    addDescriptionVersion({
+      entry,
+      reason: 'tracked',
+      seenDescriptions,
+      source: 'old_value',
+      value: entry.old_value,
+      versions,
+    });
+  }
+
+  return versions;
+}

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',
+    });
+  });
 });