@tuturuuu/utils 0.0.3 → 0.6.0

package/src/task-helper/task-hooks-move.ts

@@ -0,0 +1,264 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { moveWorkspaceTask } from '@tuturuuu/internal-api/tasks';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
+import { isTaskBoardCompletedStatus } from '../task-list-status';
+
+import { getBrowserApiOptions } from './shared';
+import { moveTask } from './task-operations';
+
+function applyOptimisticMoveToList(
+  task: Task,
+  newListId: string,
+  list?: TaskList
+): Task {
+  const now = new Date().toISOString();
+  const targetIsCompleted = isTaskBoardCompletedStatus(list?.status);
+  const targetIsClosed = list?.status === 'closed';
+
+  return {
+    ...task,
+    list_id: newListId,
+    completed: targetIsCompleted,
+    completed_at: targetIsCompleted ? (task.completed_at ?? now) : null,
+    closed_at: targetIsClosed ? (task.closed_at ?? now) : null,
+  } as Task;
+}
+
+export function useMoveTask(boardId: string, wsId?: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      taskId,
+      newListId,
+    }: {
+      taskId: string;
+      newListId: string;
+    }) => {
+      if (!wsId) {
+        console.error('Workspace ID missing for moveTask');
+        throw new Error('Workspace ID is required to move tasks');
+      }
+
+      const baseUrl =
+        typeof window !== 'undefined' ? window.location.origin : undefined;
+      const result = await moveTask(wsId, taskId, newListId, {
+        baseUrl: baseUrl ?? undefined,
+      });
+
+      return result;
+    },
+    onMutate: async ({ taskId, newListId }) => {
+      await queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
+
+      const previousTasks = queryClient.getQueryData(['tasks', boardId]);
+
+      queryClient.setQueryData(
+        ['tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return old;
+          return old.map((task) => {
+            if (task.id === taskId) {
+              const targetList = queryClient.getQueryData([
+                'task_lists',
+                boardId,
+              ]) as TaskList[] | undefined;
+              const list = targetList?.find((l) => l.id === newListId);
+              return applyOptimisticMoveToList(task, newListId, list);
+            }
+            return task;
+          });
+        }
+      );
+
+      return { previousTasks };
+    },
+    onError: (err, _variables, context) => {
+      if (context?.previousTasks) {
+        queryClient.setQueryData(['tasks', boardId], context.previousTasks);
+      }
+
+      console.error('Failed to move task:', err);
+    },
+    onSuccess: (updatedTask) => {
+      queryClient.setQueryData(
+        ['tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return old;
+          return old.map((task) =>
+            task.id === updatedTask.id ? updatedTask : task
+          );
+        }
+      );
+    },
+  });
+}
+
+export function useMoveTaskToBoard(currentBoardId: string, wsId?: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      taskId,
+      newListId,
+      targetBoardId,
+    }: {
+      taskId: string;
+      newListId: string;
+      targetBoardId?: string;
+    }) => {
+      if (!wsId) {
+        throw new Error('Workspace ID is required to move tasks');
+      }
+
+      const result = await moveWorkspaceTask(
+        wsId,
+        taskId,
+        {
+          list_id: newListId,
+          target_board_id: targetBoardId,
+        },
+        getBrowserApiOptions()
+      );
+
+      return result;
+    },
+    onMutate: async ({ taskId, newListId, targetBoardId }) => {
+      await queryClient.cancelQueries({ queryKey: ['tasks', currentBoardId] });
+      if (targetBoardId && targetBoardId !== currentBoardId) {
+        await queryClient.cancelQueries({ queryKey: ['tasks', targetBoardId] });
+      }
+
+      const previousCurrentBoardTasks = queryClient.getQueryData([
+        'tasks',
+        currentBoardId,
+      ]);
+      const previousTargetBoardTasks =
+        targetBoardId && targetBoardId !== currentBoardId
+          ? queryClient.getQueryData(['tasks', targetBoardId])
+          : null;
+
+      if (targetBoardId && targetBoardId !== currentBoardId) {
+        queryClient.setQueryData(
+          ['tasks', currentBoardId],
+          (old: Task[] | undefined) => {
+            if (!old) return old;
+            return old.filter((task) => task.id !== taskId);
+          }
+        );
+
+        queryClient.setQueryData(
+          ['tasks', targetBoardId],
+          (old: Task[] | undefined) => {
+            if (!old) return old;
+
+            const currentBoardTasks = previousCurrentBoardTasks as
+              | Task[]
+              | undefined;
+            const taskToMove = currentBoardTasks?.find((t) => t.id === taskId);
+
+            if (!taskToMove) return old;
+
+            const targetList = queryClient.getQueryData([
+              'task_lists',
+              targetBoardId,
+            ]) as TaskList[] | undefined;
+            const list = targetList?.find((l) => l.id === newListId);
+
+            const updatedTask = applyOptimisticMoveToList(
+              taskToMove,
+              newListId,
+              list
+            );
+
+            return [...old, updatedTask];
+          }
+        );
+      } else {
+        queryClient.setQueryData(
+          ['tasks', currentBoardId],
+          (old: Task[] | undefined) => {
+            if (!old) return old;
+            return old.map((task) => {
+              if (task.id === taskId) {
+                const targetList = queryClient.getQueryData([
+                  'task_lists',
+                  currentBoardId,
+                ]) as TaskList[] | undefined;
+                const list = targetList?.find((l) => l.id === newListId);
+                return applyOptimisticMoveToList(task, newListId, list);
+              }
+              return task;
+            });
+          }
+        );
+      }
+
+      return {
+        previousCurrentBoardTasks,
+        previousTargetBoardTasks,
+        targetBoardId: targetBoardId || currentBoardId,
+      };
+    },
+    onError: (err, _variables, context) => {
+      if (context?.previousCurrentBoardTasks) {
+        queryClient.setQueryData(
+          ['tasks', currentBoardId],
+          context.previousCurrentBoardTasks
+        );
+      }
+
+      if (
+        context?.previousTargetBoardTasks &&
+        context.targetBoardId !== currentBoardId
+      ) {
+        queryClient.setQueryData(
+          ['tasks', context.targetBoardId],
+          context.previousTargetBoardTasks
+        );
+      }
+
+      console.error('Failed to move task to board:', err);
+    },
+    onSuccess: (result) => {
+      if (result.movedToDifferentBoard) {
+        queryClient.setQueryData(
+          ['tasks', result.sourceBoardId],
+          (old: Task[] | undefined) => {
+            if (!old) return old;
+            return old.filter((task) => task.id !== result.task.id);
+          }
+        );
+
+        queryClient.setQueryData(
+          ['tasks', result.targetBoardId],
+          (old: Task[] | undefined) => {
+            if (!old) return [result.task];
+
+            const existingIndex = old.findIndex(
+              (task) => task.id === result.task.id
+            );
+            if (existingIndex >= 0) {
+              const updated = [...old];
+              updated[existingIndex] = result.task;
+              return updated;
+            } else {
+              return [...old, result.task];
+            }
+          }
+        );
+      } else {
+        queryClient.setQueryData(
+          ['tasks', currentBoardId],
+          (old: Task[] | undefined) => {
+            if (!old) return old;
+            return old.map((task) =>
+              task.id === result.task.id ? result.task : task
+            );
+          }
+        );
+      }
+    },
+  });
+}

package/src/task-helper/task-operations.ts

@@ -0,0 +1,278 @@
+import type { QueryClient } from '@tanstack/react-query';
+import type { InternalApiClientOptions } from '@tuturuuu/internal-api/client';
+import {
+  createWorkspaceTask,
+  getWorkspaceTask,
+  listWorkspaceBoardsWithLists,
+  moveWorkspaceTask,
+  triggerWorkspaceTaskEmbedding,
+  updateWorkspaceTask,
+} from '@tuturuuu/internal-api/tasks';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+import { isTaskBoardCompletedStatus } from '../task-list-status';
+
+import {
+  getBrowserApiOptions,
+  getMutationApiOptions,
+  toWorkspaceTaskUpdatePayload,
+} from './shared';
+
+export async function getTaskAssignees(wsId: string, taskId: string) {
+  const { task } = await getWorkspaceTask(wsId, taskId, getBrowserApiOptions());
+  return task.assignees ?? [];
+}
+
+function buildTaskArchivedStatusUpdates(
+  task: {
+    completed?: boolean | null;
+    completed_at?: string | null;
+    closed_at?: string | null;
+  },
+  listStatus: string | null | undefined
+) {
+  const updates: {
+    completed?: boolean;
+    completed_at?: string | null;
+    closed_at?: string | null;
+  } = {};
+
+  if (isTaskBoardCompletedStatus(listStatus)) {
+    if (task.completed !== true || !task.completed_at || task.closed_at) {
+      updates.completed = true;
+      updates.completed_at = task.completed_at ?? new Date().toISOString();
+      updates.closed_at = null;
+    }
+  } else if (listStatus === 'closed') {
+    if (task.completed !== false || !task.closed_at || task.completed_at) {
+      updates.completed = false;
+      updates.closed_at = new Date().toISOString();
+      updates.completed_at = null;
+    }
+  } else {
+    if (task.completed !== false) {
+      updates.completed = false;
+    }
+    if (task.completed_at) {
+      updates.completed_at = null;
+    }
+    if (task.closed_at) {
+      updates.closed_at = null;
+    }
+  }
+
+  return updates;
+}
+
+export async function createTask(
+  wsId: string,
+  listId: string,
+  task: Partial<Task> & {
+    description_yjs_state?: number[];
+    label_ids?: string[];
+    assignee_ids?: string[];
+    project_ids?: string[];
+  }
+) {
+  if (!task.name || task.name.trim().length === 0) {
+    throw new Error('Task name is required');
+  }
+
+  if (!listId) {
+    throw new Error('List ID is required');
+  }
+
+  if (!wsId) {
+    throw new Error('Workspace ID is required');
+  }
+
+  const schedulingInput = task as Partial<{
+    total_duration: number | null;
+    is_splittable: boolean | null;
+    min_split_duration_minutes: number | null;
+    max_split_duration_minutes: number | null;
+    calendar_hours: Task['calendar_hours'];
+    auto_schedule: boolean | null;
+  }>;
+
+  const options = await getMutationApiOptions();
+  const { task: createdTask } = await createWorkspaceTask(
+    wsId,
+    {
+      name: task.name.trim(),
+      description: task.description || null,
+      description_yjs_state: task.description_yjs_state ?? null,
+      listId,
+      priority: task.priority || null,
+      start_date: task.start_date || null,
+      end_date: task.end_date || null,
+      estimation_points: task.estimation_points ?? null,
+      label_ids: task.label_ids ?? [],
+      assignee_ids: task.assignee_ids ?? [],
+      project_ids: task.project_ids ?? [],
+      total_duration: schedulingInput.total_duration ?? null,
+      is_splittable: schedulingInput.is_splittable ?? null,
+      min_split_duration_minutes:
+        schedulingInput.min_split_duration_minutes ?? null,
+      max_split_duration_minutes:
+        schedulingInput.max_split_duration_minutes ?? null,
+      calendar_hours: schedulingInput.calendar_hours ?? null,
+      auto_schedule: schedulingInput.auto_schedule ?? null,
+    },
+    options
+  );
+
+  return createdTask as Task;
+}
+
+export async function updateTask(
+  wsId: string,
+  taskId: string,
+  task: Partial<Task> & { completed?: boolean }
+) {
+  if (!wsId) {
+    throw new Error('Workspace ID is required');
+  }
+
+  const options = await getMutationApiOptions();
+  const { task: data } = await updateWorkspaceTask(
+    wsId,
+    taskId,
+    toWorkspaceTaskUpdatePayload(task),
+    options
+  );
+
+  if ((task.name !== undefined || task.description !== undefined) && data) {
+    triggerWorkspaceTaskEmbedding(wsId, taskId, options).catch(
+      (err: unknown) => {
+        console.error('Failed to regenerate embedding:', err);
+      }
+    );
+  }
+
+  return data as Task;
+}
+
+export async function invalidateTaskCaches(
+  queryClient: QueryClient,
+  boardId?: string
+) {
+  const promises: Promise<void>[] = [];
+
+  if (boardId) {
+    promises.push(
+      queryClient.invalidateQueries({ queryKey: ['tasks', boardId] })
+    );
+    promises.push(
+      queryClient.invalidateQueries({ queryKey: ['task_lists', boardId] })
+    );
+  }
+
+  promises.push(
+    queryClient.invalidateQueries({ queryKey: ['time-tracking-data'] })
+  );
+
+  await Promise.all(promises);
+}
+
+export async function syncTaskArchivedStatus(
+  wsId: string,
+  taskId: string,
+  listId: string,
+  options?: InternalApiClientOptions
+) {
+  const clientOptions = options ?? getBrowserApiOptions();
+  const [{ boards }, { task }] = await Promise.all([
+    listWorkspaceBoardsWithLists(wsId, clientOptions),
+    getWorkspaceTask(wsId, taskId, clientOptions),
+  ]);
+
+  const list = boards
+    .flatMap((board) => board.task_lists)
+    .find((entry) => entry.id === listId);
+
+  if (!list) {
+    console.error('Error fetching list status: list not found', { listId });
+    throw new Error(`Task list not found: ${listId}`);
+  }
+  const updates = buildTaskArchivedStatusUpdates(task, list.status);
+
+  if (Object.keys(updates).length === 0) {
+    return;
+  }
+
+  try {
+    const mutationOptions = options ?? (await getMutationApiOptions());
+    await updateWorkspaceTask(wsId, taskId, updates, mutationOptions);
+  } catch (updateError) {
+    console.error('Error syncing task archived status:', updateError);
+    throw updateError;
+  }
+}
+
+export async function moveTask(
+  wsId: string,
+  taskId: string,
+  newListId: string,
+  options?: InternalApiClientOptions
+) {
+  const clientOptions = options ?? getBrowserApiOptions();
+  const [{ boards }, { task }] = await Promise.all([
+    listWorkspaceBoardsWithLists(wsId, clientOptions),
+    getWorkspaceTask(wsId, taskId, clientOptions),
+  ]);
+
+  const targetList = boards
+    .flatMap((board) => board.task_lists)
+    .find((list) => list.id === newListId);
+
+  if (!targetList) {
+    throw new Error(`Task list not found: ${newListId}`);
+  }
+
+  const updates = buildTaskArchivedStatusUpdates(task, targetList.status);
+  const mutationOptions = options ?? (await getMutationApiOptions());
+
+  await updateWorkspaceTask(
+    wsId,
+    taskId,
+    {
+      list_id: newListId,
+      ...updates,
+    },
+    mutationOptions
+  );
+
+  const { task: updatedTask } = await getWorkspaceTask(
+    wsId,
+    taskId,
+    clientOptions
+  );
+  return updatedTask as Task;
+}
+
+export async function moveTaskToBoard(
+  wsId: string,
+  taskId: string,
+  newListId: string,
+  targetBoardId?: string
+) {
+  if (!wsId) {
+    throw new Error('Workspace ID is required');
+  }
+
+  const options = await getMutationApiOptions();
+  const result = await moveWorkspaceTask(
+    wsId,
+    taskId,
+    {
+      list_id: newListId,
+      target_board_id: targetBoardId,
+    },
+    options
+  );
+
+  return {
+    ...result,
+    task: result.task as Task,
+  };
+}

package/src/task-helper.ts

@@ -0,0 +1,12 @@
+export { reorderTask, useReorderTask } from './task/reorder';
+export { transformAssignees, transformTaskRecord } from './task/transformers';
+export * from './task-helper/board';
+export * from './task-helper/bulk-actions';
+export * from './task-helper/personal-external-staging';
+export * from './task-helper/recycle-bin';
+export * from './task-helper/relationships';
+export { getTicketIdentifier } from './task-helper/shared';
+export * from './task-helper/sort-keys';
+export * from './task-helper/task-hooks-basic';
+export * from './task-helper/task-hooks-move';
+export * from './task-helper/task-operations';