@tuturuuu/utils 0.0.2 → 0.6.0

package/src/task-helper/recycle-bin.ts

@@ -0,0 +1,202 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import {
+  deleteWorkspaceTask,
+  listWorkspaceTasks,
+  updateWorkspaceTask,
+} from '@tuturuuu/internal-api/tasks';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+
+import { transformTaskRecord } from '../task/transformers';
+import { getBrowserApiOptions } from './shared';
+
+type UseDeletedTasksOptions = {
+  enabled?: boolean;
+  staleTime?: number;
+};
+
+export function useDeletedTasks(
+  boardId: string,
+  wsId: string,
+  options?: UseDeletedTasksOptions
+) {
+  return useQuery({
+    queryKey: ['deleted-tasks', boardId],
+    queryFn: async () => {
+      const clientOptions = getBrowserApiOptions();
+      const { tasks } = await listWorkspaceTasks(
+        wsId,
+        {
+          boardId,
+          includeDeleted: 'only',
+        },
+        clientOptions
+      );
+
+      return tasks.map((task) => transformTaskRecord(task));
+    },
+    enabled: options?.enabled,
+    staleTime: options?.staleTime ?? 5 * 60 * 1000,
+  });
+}
+
+export function useRestoreTasks(boardId: string, wsId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      taskIds,
+      fallbackListId,
+    }: {
+      taskIds: string[];
+      fallbackListId?: string;
+    }) => {
+      const restoredTasks: Task[] = [];
+      for (const taskId of taskIds) {
+        try {
+          const { task } = await updateWorkspaceTask(
+            wsId,
+            taskId,
+            { deleted: false },
+            getBrowserApiOptions()
+          );
+          restoredTasks.push(task as Task);
+        } catch (error) {
+          if (!fallbackListId) {
+            throw error;
+          }
+
+          const { task } = await updateWorkspaceTask(
+            wsId,
+            taskId,
+            { deleted: false, list_id: fallbackListId },
+            getBrowserApiOptions()
+          );
+          restoredTasks.push(task as Task);
+        }
+      }
+
+      return restoredTasks;
+    },
+    onMutate: async ({ taskIds }) => {
+      await queryClient.cancelQueries({ queryKey: ['deleted-tasks', boardId] });
+      await queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
+
+      const previousDeletedTasks = queryClient.getQueryData([
+        'deleted-tasks',
+        boardId,
+      ]) as Task[] | undefined;
+      const previousTasks = queryClient.getQueryData(['tasks', boardId]) as
+        | Task[]
+        | undefined;
+
+      const restoringTasks =
+        previousDeletedTasks?.filter((t) => taskIds.includes(t.id)) || [];
+
+      queryClient.setQueryData(
+        ['deleted-tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return old;
+          return old.filter((task) => !taskIds.includes(task.id));
+        }
+      );
+
+      queryClient.setQueryData(
+        ['tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old)
+            return restoringTasks.map((t) => ({ ...t, deleted_at: null }));
+          return [
+            ...old,
+            ...restoringTasks.map((t) => ({ ...t, deleted_at: null })),
+          ];
+        }
+      );
+
+      return { previousDeletedTasks, previousTasks };
+    },
+    onError: (err, _, context) => {
+      if (context?.previousDeletedTasks) {
+        queryClient.setQueryData(
+          ['deleted-tasks', boardId],
+          context.previousDeletedTasks
+        );
+      }
+      if (context?.previousTasks) {
+        queryClient.setQueryData(['tasks', boardId], context.previousTasks);
+      }
+
+      queryClient.invalidateQueries({ queryKey: ['deleted-tasks', boardId] });
+      queryClient.invalidateQueries({ queryKey: ['tasks', boardId] });
+      console.error('Failed to restore tasks:', err);
+    },
+    onSuccess: (restoredTasks) => {
+      queryClient.setQueryData(
+        ['tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return restoredTasks;
+          const restoredIds = new Set(restoredTasks.map((t) => t.id));
+          const otherTasks = old.filter((t) => !restoredIds.has(t.id));
+          return [...otherTasks, ...restoredTasks];
+        }
+      );
+    },
+  });
+}
+
+export function usePermanentlyDeleteTasks(boardId: string, wsId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (taskIds: string[]) => {
+      let count = 0;
+      const failedTaskIds: string[] = [];
+
+      for (const taskId of taskIds) {
+        try {
+          await deleteWorkspaceTask(wsId, taskId, getBrowserApiOptions());
+          count++;
+        } catch (error) {
+          console.error(`Failed to permanently delete task ${taskId}:`, error);
+          failedTaskIds.push(taskId);
+        }
+      }
+
+      if (failedTaskIds.length > 0) {
+        throw new Error(
+          `Failed to permanently delete ${failedTaskIds.length} task${failedTaskIds.length === 1 ? '' : 's'}`
+        );
+      }
+
+      return { count, failedTaskIds };
+    },
+    onMutate: async (taskIds) => {
+      await queryClient.cancelQueries({ queryKey: ['deleted-tasks', boardId] });
+
+      const previousDeletedTasks = queryClient.getQueryData([
+        'deleted-tasks',
+        boardId,
+      ]) as Task[] | undefined;
+
+      queryClient.setQueryData(
+        ['deleted-tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return old;
+          return old.filter((task) => !taskIds.includes(task.id));
+        }
+      );
+
+      return { previousDeletedTasks };
+    },
+    onError: (err, _, context) => {
+      if (context?.previousDeletedTasks) {
+        queryClient.setQueryData(
+          ['deleted-tasks', boardId],
+          context.previousDeletedTasks
+        );
+      }
+
+      queryClient.invalidateQueries({ queryKey: ['deleted-tasks', boardId] });
+      console.error('Failed to permanently delete tasks:', err);
+    },
+  });
+}

package/src/task-helper/relationships.ts

@@ -0,0 +1,346 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import {
+  createWorkspaceTaskRelationship,
+  createWorkspaceTaskWithRelationship,
+  deleteWorkspaceTaskRelationship,
+  getWorkspaceTaskRelationships,
+  listWorkspaceTasks,
+} from '@tuturuuu/internal-api/tasks';
+import { isTaskPriority } from '@tuturuuu/types/primitives/Priority';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+import type {
+  CreateTaskRelationshipInput,
+  CreateTaskWithRelationshipInput,
+  RelatedTaskInfo,
+  TaskRelationship,
+  TaskRelationshipsResponse,
+  TaskRelationshipType,
+} from '@tuturuuu/types/primitives/TaskRelationship';
+
+import {
+  getBrowserApiOptions,
+  getMutationApiOptions,
+  getTaskIdentifierForSearch,
+  isTicketIdentifierLikeQuery,
+  normalizeTaskSearchValue,
+} from './shared';
+
+export type TaskRelationshipErrorCode =
+  | 'already_exists'
+  | 'single_parent'
+  | 'circular';
+
+export class TaskRelationshipError extends Error {
+  constructor(public readonly code: TaskRelationshipErrorCode) {
+    super(code);
+    this.name = 'TaskRelationshipError';
+  }
+}
+
+export async function getTaskRelationships(
+  wsId: string,
+  taskId: string
+): Promise<TaskRelationshipsResponse> {
+  const payload = await getWorkspaceTaskRelationships(
+    wsId,
+    taskId,
+    getBrowserApiOptions()
+  );
+  return payload;
+}
+
+export async function createTaskRelationship(
+  wsId: string,
+  input: CreateTaskRelationshipInput
+): Promise<TaskRelationship> {
+  const options = await getMutationApiOptions();
+
+  try {
+    const { relationship } = await createWorkspaceTaskRelationship(
+      wsId,
+      input.source_task_id,
+      input,
+      options
+    );
+    return relationship;
+  } catch (error) {
+    const typedError = error as Error & { code?: string };
+    if (
+      typedError.code === '23505' ||
+      typedError.message?.includes('already exists')
+    ) {
+      throw new TaskRelationshipError('already_exists');
+    }
+    if (typedError.message?.includes('single parent')) {
+      throw new TaskRelationshipError('single_parent');
+    }
+    if (typedError.message?.includes('circular')) {
+      throw new TaskRelationshipError('circular');
+    }
+    throw error;
+  }
+}
+
+export async function deleteTaskRelationship(
+  wsId: string,
+  relationship?: Pick<
+    TaskRelationship,
+    'source_task_id' | 'target_task_id' | 'type'
+  >
+): Promise<void> {
+  if (!relationship) {
+    throw new Error(
+      'deleteTaskRelationship requires source_task_id, target_task_id, and type.'
+    );
+  }
+
+  const options = await getMutationApiOptions();
+  await deleteWorkspaceTaskRelationship(
+    wsId,
+    relationship.source_task_id,
+    {
+      source_task_id: relationship.source_task_id,
+      target_task_id: relationship.target_task_id,
+      type: relationship.type,
+    },
+    options
+  );
+}
+
+export function useTaskRelationships(
+  taskId: string | undefined,
+  wsId?: string
+) {
+  return useQuery({
+    queryKey: ['task-relationships', taskId, wsId],
+    queryFn: async () => {
+      if (!taskId || !wsId) return null;
+      const relationships = await getWorkspaceTaskRelationships(
+        wsId,
+        taskId,
+        getBrowserApiOptions()
+      );
+      return relationships;
+    },
+    enabled: !!taskId && !!wsId,
+    staleTime: 30000,
+  });
+}
+
+export function useCreateTaskRelationship(wsId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (input: CreateTaskRelationshipInput) =>
+      createTaskRelationship(wsId, input),
+    onSuccess: async (_, variables) => {
+      await Promise.all([
+        queryClient.invalidateQueries({
+          queryKey: ['task-relationships', variables.source_task_id],
+        }),
+        queryClient.invalidateQueries({
+          queryKey: ['task-relationships', variables.target_task_id],
+        }),
+      ]);
+    },
+  });
+}
+
+export function useDeleteTaskRelationship(wsId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      sourceTaskId,
+      targetTaskId,
+      type,
+    }: {
+      sourceTaskId: string;
+      targetTaskId: string;
+      type: TaskRelationshipType;
+    }) => {
+      return deleteTaskRelationship(wsId, {
+        source_task_id: sourceTaskId,
+        target_task_id: targetTaskId,
+        type,
+      });
+    },
+    onSuccess: async (_, variables) => {
+      await Promise.all([
+        queryClient.invalidateQueries({
+          queryKey: ['task-relationships', variables.sourceTaskId],
+        }),
+        queryClient.invalidateQueries({
+          queryKey: ['task-relationships', variables.targetTaskId],
+        }),
+      ]);
+    },
+  });
+}
+
+export async function getWorkspaceTasks(
+  wsId: string,
+  options?: {
+    excludeTaskIds?: string[];
+    searchQuery?: string;
+    limit?: number;
+  }
+): Promise<RelatedTaskInfo[]> {
+  const excluded = new Set(options?.excludeTaskIds ?? []);
+  const normalizedSearch = options?.searchQuery
+    ? normalizeTaskSearchValue(options.searchQuery)
+    : '';
+  const ticketLikeSearch = normalizedSearch
+    ? isTicketIdentifierLikeQuery(normalizedSearch)
+    : false;
+  const targetLimit = options?.limit ?? 50;
+  const requestLimit = Math.max(25, Math.min(targetLimit * 2, 200));
+  const collected: RelatedTaskInfo[] = [];
+  const seenTaskIds = new Set<string>();
+
+  const clientOptions =
+    typeof window !== 'undefined'
+      ? {
+          baseUrl: window.location.origin,
+          fetch: (input: RequestInfo | URL, init?: RequestInit) =>
+            fetch(input, { ...init, cache: init?.cache ?? 'no-store' }),
+        }
+      : undefined;
+
+  let offset = 0;
+  while (true) {
+    const { tasks } = await listWorkspaceTasks(
+      wsId,
+      {
+        q: ticketLikeSearch ? undefined : options?.searchQuery,
+        identifier: ticketLikeSearch ? options?.searchQuery : undefined,
+        limit: requestLimit,
+        offset,
+        includeRelationshipSummary: !ticketLikeSearch,
+      },
+      clientOptions
+    );
+
+    const pageTasks = tasks ?? [];
+    if (pageTasks.length === 0) {
+      break;
+    }
+
+    for (const task of pageTasks) {
+      if (excluded.has(task.id) || seenTaskIds.has(task.id)) {
+        continue;
+      }
+
+      if (normalizedSearch) {
+        const taskName = normalizeTaskSearchValue(task.name ?? '');
+        const taskIdentifier = normalizeTaskSearchValue(
+          getTaskIdentifierForSearch(task) ?? ''
+        );
+
+        if (
+          !taskName.includes(normalizedSearch) &&
+          !taskIdentifier.includes(normalizedSearch)
+        ) {
+          continue;
+        }
+      }
+
+      seenTaskIds.add(task.id);
+      collected.push({
+        id: task.id,
+        name: task.name,
+        display_number: task.display_number,
+        ticket_prefix: task.ticket_prefix ?? null,
+        completed: !!task.closed_at || !!task.completed_at,
+        priority: isTaskPriority(task.priority) ? task.priority : null,
+        board_id: task.board_id ?? null,
+        board_name: task.board_name,
+      });
+
+      if (collected.length >= targetLimit) {
+        return collected;
+      }
+    }
+
+    if (pageTasks.length < requestLimit) {
+      break;
+    }
+
+    offset += requestLimit;
+  }
+
+  return collected;
+}
+
+export function useWorkspaceTasks(
+  wsId: string | undefined,
+  options?: {
+    excludeTaskIds?: string[];
+    searchQuery?: string;
+    limit?: number;
+    enabled?: boolean;
+  }
+) {
+  return useQuery({
+    queryKey: [
+      'workspace-tasks',
+      wsId,
+      options?.excludeTaskIds,
+      options?.searchQuery,
+      options?.limit,
+    ],
+    queryFn: async () => {
+      if (!wsId) return [];
+      return getWorkspaceTasks(wsId, options);
+    },
+    enabled: !!wsId && (options?.enabled ?? true),
+    staleTime: 30000,
+  });
+}
+
+export function useCreateTaskWithRelationship(boardId: string, wsId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (input: CreateTaskWithRelationshipInput) => {
+      const result = await createWorkspaceTaskWithRelationship(
+        wsId,
+        input,
+        getBrowserApiOptions()
+      );
+      return {
+        task: result.task as Task,
+        relationship: result.relationship,
+      };
+    },
+    onSuccess: async (result, variables) => {
+      const locallyCreatedTask = {
+        ...(result.task as Task & { _localMutationAt?: number }),
+        _localMutationAt: Date.now(),
+      } as Task;
+
+      if (boardId) {
+        queryClient.setQueryData(
+          ['tasks', boardId],
+          (old: Task[] | undefined) => {
+            if (!old) return [locallyCreatedTask];
+            if (old.some((t) => t.id === result.task.id)) return old;
+            return [...old, locallyCreatedTask];
+          }
+        );
+      }
+
+      await Promise.all([
+        queryClient.invalidateQueries({
+          queryKey: ['task-relationships', variables.currentTaskId],
+        }),
+        queryClient.invalidateQueries({
+          queryKey: ['task-relationships', result.task.id],
+        }),
+        queryClient.invalidateQueries({
+          queryKey: ['workspace-tasks', wsId],
+        }),
+      ]);
+    },
+  });
+}

package/src/task-helper/shared.ts

@@ -0,0 +1,109 @@
+import type { InternalApiClientOptions } from '@tuturuuu/internal-api/client';
+import { listWorkspaceTasks } from '@tuturuuu/internal-api/tasks';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+
+export function getTicketIdentifier(
+  prefix: string | null | undefined,
+  displayNumber: number
+): string {
+  const effectivePrefix = prefix?.trim() || 'TASK';
+  return `${effectivePrefix}-${displayNumber}`.toUpperCase();
+}
+
+export function normalizeTaskSearchValue(value: string) {
+  return value.trim().toLowerCase();
+}
+
+export function isTicketIdentifierLikeQuery(query: string) {
+  const normalized = normalizeTaskSearchValue(query);
+  if (!normalized) return false;
+  return /^\d+$/.test(normalized) || /^[a-z][a-z0-9_-]*-\d+$/.test(normalized);
+}
+
+export function getTaskIdentifierForSearch(task: {
+  ticket_prefix?: string | null;
+  display_number?: number | null;
+}) {
+  if (typeof task.display_number !== 'number') {
+    return null;
+  }
+
+  return getTicketIdentifier(task.ticket_prefix, task.display_number);
+}
+
+export async function getMutationApiOptions(): Promise<
+  InternalApiClientOptions | undefined
+> {
+  if (typeof window !== 'undefined') {
+    return { baseUrl: window.location.origin };
+  }
+
+  return undefined;
+}
+
+export function getBrowserApiOptions(): InternalApiClientOptions | undefined {
+  if (typeof window === 'undefined') {
+    return undefined;
+  }
+
+  return { baseUrl: window.location.origin };
+}
+
+export async function listAllActiveTasksForList(wsId: string, listId: string) {
+  const tasks: Task[] = [];
+  const pageSize = 200;
+  let offset = 0;
+
+  while (true) {
+    const { tasks: page } = await listWorkspaceTasks(
+      wsId,
+      {
+        listId,
+        limit: pageSize,
+        offset,
+        includeDeleted: false,
+      },
+      getBrowserApiOptions()
+    );
+
+    if (!page.length) {
+      break;
+    }
+
+    tasks.push(...(page as Task[]));
+
+    if (page.length < pageSize) {
+      break;
+    }
+
+    offset += pageSize;
+  }
+
+  return tasks;
+}
+
+export function toWorkspaceTaskUpdatePayload(
+  task: Partial<Task> & { completed?: boolean }
+) {
+  return {
+    ...(task.name !== undefined ? { name: task.name } : {}),
+    ...(task.description !== undefined
+      ? { description: task.description }
+      : {}),
+    ...(task.priority !== undefined ? { priority: task.priority } : {}),
+    ...(task.start_date !== undefined ? { start_date: task.start_date } : {}),
+    ...(task.end_date !== undefined ? { end_date: task.end_date } : {}),
+    ...(task.closed_at !== undefined ? { closed_at: task.closed_at } : {}),
+    ...(task.completed_at !== undefined
+      ? { completed_at: task.completed_at }
+      : {}),
+    ...(task.list_id !== undefined ? { list_id: task.list_id } : {}),
+    ...(task.estimation_points !== undefined
+      ? { estimation_points: task.estimation_points }
+      : {}),
+    ...(task.completed !== undefined ? { completed: task.completed } : {}),
+    ...(task.sort_key !== undefined && task.sort_key !== null
+      ? { sort_key: task.sort_key }
+      : {}),
+  };
+}