@tuturuuu/utils 0.0.3 → 0.6.1

package/src/task-helper/sort-keys.ts

@@ -0,0 +1,337 @@
+import { updateWorkspaceTask } from '@tuturuuu/internal-api/tasks';
+import type { TaskPriority } from '@tuturuuu/types/primitives/Priority';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+
+import { getMutationApiOptions, listAllActiveTasksForList } from './shared';
+
+export function priorityCompare(
+  priorityA: TaskPriority | null | undefined,
+  priorityB: TaskPriority | null | undefined
+) {
+  const priorityOrder = {
+    critical: 4,
+    high: 3,
+    normal: 2,
+    low: 1,
+  };
+
+  const getOrderValue = (priority: TaskPriority | null | undefined): number => {
+    return priority ? priorityOrder[priority] : 0;
+  };
+
+  const valueA = getOrderValue(priorityA);
+  const valueB = getOrderValue(priorityB);
+
+  return valueB - valueA;
+}
+
+const SORT_KEY_BASE_UNIT = 1000000;
+const SORT_KEY_DEFAULT = SORT_KEY_BASE_UNIT * 1000;
+const SORT_KEY_MIN_GAP = 1000;
+
+let sortKeySequence = 0;
+
+export class SortKeyGapExhaustedError extends Error {
+  constructor(
+    public readonly prevSortKey: number | null | undefined,
+    public readonly nextSortKey: number | null | undefined,
+    message: string
+  ) {
+    super(message);
+    this.name = 'SortKeyGapExhaustedError';
+  }
+}
+
+export function calculateSortKey(
+  prevSortKey: number | null | undefined,
+  nextSortKey: number | null | undefined
+): number {
+  sortKeySequence = (sortKeySequence % 999) + 1;
+
+  if (prevSortKey === null || prevSortKey === undefined) {
+    if (nextSortKey === null || nextSortKey === undefined) {
+      return SORT_KEY_DEFAULT + sortKeySequence;
+    }
+
+    if (nextSortKey <= 1) {
+      throw new SortKeyGapExhaustedError(
+        null,
+        nextSortKey,
+        `Cannot insert before sort key ${nextSortKey}. No positive integer exists strictly less than it. Normalization required.`
+      );
+    }
+
+    const halfNext = Math.floor(nextSortKey / 2);
+
+    if (nextSortKey <= SORT_KEY_MIN_GAP) {
+      const result = Math.max(1, Math.min(halfNext, nextSortKey - 1));
+      return result;
+    } else {
+      const baseKey = Math.max(
+        halfNext,
+        Math.min(SORT_KEY_BASE_UNIT, nextSortKey - SORT_KEY_MIN_GAP)
+      );
+      const maxSequence = nextSortKey - baseKey - 1;
+      const safeSequence = Math.min(sortKeySequence, Math.max(0, maxSequence));
+      return baseKey + safeSequence;
+    }
+  }
+
+  if (nextSortKey === null || nextSortKey === undefined) {
+    return prevSortKey + SORT_KEY_BASE_UNIT + sortKeySequence;
+  }
+
+  const gap = nextSortKey - prevSortKey;
+
+  if (gap <= 0) {
+    throw new SortKeyGapExhaustedError(
+      prevSortKey,
+      nextSortKey,
+      `Cannot insert between inverted sort keys ${prevSortKey} and ${nextSortKey}. Gap (${gap}) is inverted or zero. Normalization required.`
+    );
+  }
+
+  if (gap <= 1) {
+    throw new SortKeyGapExhaustedError(
+      prevSortKey,
+      nextSortKey,
+      `Cannot insert between sort keys ${prevSortKey} and ${nextSortKey}. Gap (${gap}) is too small. Normalization required.`
+    );
+  }
+
+  const midpoint = Math.floor((prevSortKey + nextSortKey) / 2);
+
+  if (midpoint <= prevSortKey || midpoint >= nextSortKey) {
+    throw new SortKeyGapExhaustedError(
+      prevSortKey,
+      nextSortKey,
+      `Calculated midpoint ${midpoint} is not strictly between ${prevSortKey} and ${nextSortKey}. Gap exhausted. Normalization required.`
+    );
+  }
+
+  if (gap <= sortKeySequence) {
+    console.warn(
+      '⚠️ Gap too small for sequence offset, using midpoint - normalization recommended',
+      { prevSortKey, nextSortKey, gap, sortKeySequence, midpoint }
+    );
+    return midpoint;
+  }
+
+  if (gap <= SORT_KEY_MIN_GAP) {
+    console.warn(
+      '⚠️ Sort key gap small, task ordering may need renormalization',
+      { prevSortKey, nextSortKey, gap, threshold: SORT_KEY_MIN_GAP }
+    );
+
+    const maxOffsetUp = nextSortKey - 1 - midpoint;
+    const maxOffsetDown = midpoint - prevSortKey - 1;
+    const maxSafeOffset = Math.min(maxOffsetUp, maxOffsetDown);
+    const safeOffset = Math.min(sortKeySequence, Math.max(0, maxSafeOffset));
+
+    const result = midpoint + safeOffset;
+
+    if (result <= prevSortKey || result >= nextSortKey) {
+      throw new SortKeyGapExhaustedError(
+        prevSortKey,
+        nextSortKey,
+        `Calculated result ${result} with offset is not strictly between ${prevSortKey} and ${nextSortKey}. Normalization required.`
+      );
+    }
+
+    return result;
+  }
+
+  const halfGap = Math.floor(gap / 2);
+  const offset = Math.min(sortKeySequence, halfGap - 1);
+
+  const result = midpoint + offset;
+
+  if (result <= prevSortKey || result >= nextSortKey) {
+    throw new SortKeyGapExhaustedError(
+      prevSortKey,
+      nextSortKey,
+      `Calculated result ${result} with offset is not strictly between ${prevSortKey} and ${nextSortKey}. Normalization required.`
+    );
+  }
+
+  return result;
+}
+
+export function calculateTopSortKey(
+  nextSortKey: number | null | undefined
+): number {
+  return calculateSortKey(null, nextSortKey);
+}
+
+export function calculateBottomSortKey(
+  prevSortKey: number | null | undefined
+): number {
+  return calculateSortKey(prevSortKey, null);
+}
+
+export function resetSortKeySequence(): void {
+  sortKeySequence = 0;
+}
+
+export function getSortKeyConfig(): {
+  BASE_UNIT: number;
+  DEFAULT: number;
+  MIN_GAP: number;
+} {
+  return {
+    BASE_UNIT: SORT_KEY_BASE_UNIT,
+    DEFAULT: SORT_KEY_DEFAULT,
+    MIN_GAP: SORT_KEY_MIN_GAP,
+  };
+}
+
+type SortKeyLike = { sort_key?: number | null | undefined };
+
+export function hasSortKeyCollisions(tasks: SortKeyLike[]): boolean {
+  const sortKeys = tasks
+    .map((t) => t.sort_key)
+    .filter((key): key is number => key !== null && key !== undefined);
+
+  if (sortKeys.length === 0) return false;
+
+  const sorted = [...sortKeys].sort((a, b) => a - b);
+
+  for (let i = 1; i < sorted.length; i++) {
+    const prevKey = sorted[i - 1];
+    const currKey = sorted[i];
+    if (prevKey !== undefined && currKey !== undefined) {
+      const gap = currKey - prevKey;
+      if (gap < SORT_KEY_MIN_GAP) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+export function normalizeSortKeys(tasks: Task[]): Task[] {
+  const sorted = [...tasks].sort((a, b) => {
+    const sortA = a.sort_key ?? Number.MAX_SAFE_INTEGER;
+    const sortB = b.sort_key ?? Number.MAX_SAFE_INTEGER;
+    if (sortA !== sortB) return sortA - sortB;
+    return new Date(a.created_at).getTime() - new Date(b.created_at).getTime();
+  });
+
+  return sorted.map((task, index) => ({
+    ...task,
+    sort_key: (index + 1) * SORT_KEY_BASE_UNIT,
+  }));
+}
+
+function sortTasksByPersistedOrder(
+  tasks: Pick<Task, 'id' | 'sort_key' | 'created_at'>[]
+) {
+  return [...tasks].sort((a, b) => {
+    const sortA = a.sort_key ?? Number.MAX_SAFE_INTEGER;
+    const sortB = b.sort_key ?? Number.MAX_SAFE_INTEGER;
+    if (sortA !== sortB) return sortA - sortB;
+    return new Date(a.created_at).getTime() - new Date(b.created_at).getTime();
+  });
+}
+
+function reorderCanonicalTasksFromVisualOrder(
+  canonicalTasks: Pick<Task, 'id' | 'sort_key' | 'created_at'>[],
+  visualOrderTasks: Pick<Task, 'id' | 'sort_key' | 'created_at'>[]
+) {
+  const visualOrderById = new Map(
+    visualOrderTasks.map((task, index) => [task.id, index] as const)
+  );
+
+  const coversCanonicalList =
+    visualOrderById.size === canonicalTasks.length &&
+    canonicalTasks.every((task) => visualOrderById.has(task.id));
+
+  if (!coversCanonicalList) {
+    return canonicalTasks;
+  }
+
+  return [...canonicalTasks].sort(
+    (a, b) => visualOrderById.get(a.id)! - visualOrderById.get(b.id)!
+  );
+}
+
+export async function normalizeListSortKeys(
+  wsId: string,
+  listId: string,
+  visualOrderTasks?: Pick<Task, 'id' | 'sort_key' | 'created_at'>[]
+): Promise<void> {
+  if (visualOrderTasks !== undefined) {
+    if (visualOrderTasks.length === 0) {
+      return;
+    }
+  }
+
+  const fetchedTasks = await listAllActiveTasksForList(wsId, listId);
+
+  if (!fetchedTasks.length) {
+    return;
+  }
+
+  const canonicalTasks = sortTasksByPersistedOrder(
+    fetchedTasks.map((task) => ({
+      id: task.id,
+      sort_key: task.sort_key ?? null,
+      created_at: task.created_at,
+    }))
+  );
+
+  const tasks =
+    visualOrderTasks !== undefined
+      ? reorderCanonicalTasksFromVisualOrder(canonicalTasks, visualOrderTasks)
+      : canonicalTasks;
+
+  if (!visualOrderTasks) {
+    const needsNormalization = hasSortKeyCollisions(tasks);
+
+    if (!needsNormalization) {
+      return;
+    }
+  }
+
+  const updates = tasks.map((task, index) => ({
+    id: task.id,
+    sort_key: (index + 1) * SORT_KEY_BASE_UNIT,
+  }));
+
+  const options = await getMutationApiOptions();
+
+  const concurrency = 5;
+  const errors: Error[] = [];
+
+  for (let index = 0; index < updates.length; index += concurrency) {
+    const chunk = updates.slice(index, index + concurrency);
+    const results = await Promise.allSettled(
+      chunk.map((update) =>
+        updateWorkspaceTask(
+          wsId,
+          update.id,
+          { sort_key: update.sort_key },
+          options
+        )
+      )
+    );
+
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        errors.push(
+          result.reason instanceof Error
+            ? result.reason
+            : new Error(String(result.reason))
+        );
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new AggregateError(
+      errors,
+      `Failed to update ${errors.length} task(s) during normalization`
+    );
+  }
+}

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

@@ -0,0 +1,342 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import {
+  createWorkspaceTask,
+  getWorkspaceTaskRelationships,
+  updateWorkspaceTask,
+} from '@tuturuuu/internal-api/tasks';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+
+import { getBrowserApiOptions, toWorkspaceTaskUpdatePayload } from './shared';
+
+export function useUpdateTask(boardId: string, wsId?: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      taskId,
+      updates,
+    }: {
+      taskId: string;
+      updates: Partial<Task>;
+    }) => {
+      if (!wsId) {
+        throw new Error('Workspace ID is required to update tasks');
+      }
+      const { task } = await updateWorkspaceTask(
+        wsId,
+        taskId,
+        toWorkspaceTaskUpdatePayload(updates),
+        getBrowserApiOptions()
+      );
+      return task as Task;
+    },
+    onMutate: async ({ taskId, updates }) => {
+      await queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
+
+      const previousTasks = queryClient.getQueryData(['tasks', boardId]);
+
+      let blockedTaskIdsPromise: Promise<string[]> | null = null;
+      if (
+        updates.completed_at !== undefined ||
+        updates.closed_at !== undefined
+      ) {
+        if (wsId) {
+          blockedTaskIdsPromise = Promise.resolve(
+            getWorkspaceTaskRelationships(wsId, taskId, getBrowserApiOptions())
+          )
+            .then((relationships) =>
+              (relationships.blocking ?? []).map((task) => task.id)
+            )
+            .catch((err: unknown) => {
+              console.error('Failed to fetch blocked task IDs:', err);
+              return [];
+            });
+        }
+      }
+
+      queryClient.setQueryData(
+        ['tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return old;
+          return old.map((task) =>
+            task.id === taskId ? { ...task, ...updates } : task
+          );
+        }
+      );
+
+      return { previousTasks, blockedTaskIdsPromise };
+    },
+    onError: (err, _, context) => {
+      if (context?.previousTasks) {
+        queryClient.setQueryData(['tasks', boardId], context.previousTasks);
+      }
+
+      console.error('Failed to update task:', err);
+    },
+    onSuccess: async (updatedTask, variables, context) => {
+      queryClient.setQueryData(
+        ['tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return old;
+          return old.map((task) => {
+            if (task.id === updatedTask.id) {
+              return {
+                ...task,
+                ...updatedTask,
+              };
+            }
+            return task;
+          });
+        }
+      );
+
+      if (
+        variables.updates.completed_at !== undefined ||
+        variables.updates.closed_at !== undefined
+      ) {
+        await queryClient.invalidateQueries({
+          queryKey: ['task-relationships', variables.taskId],
+        });
+
+        if (context?.blockedTaskIdsPromise) {
+          const blockedTaskIds = await context.blockedTaskIdsPromise;
+          if (blockedTaskIds.length > 0) {
+            await Promise.all(
+              blockedTaskIds.map((blockedTaskId) =>
+                queryClient.invalidateQueries({
+                  queryKey: ['task-relationships', blockedTaskId],
+                })
+              )
+            );
+          }
+        }
+      }
+    },
+  });
+}
+
+export function useCreateTask(boardId: string, wsId?: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      listId,
+      task,
+    }: {
+      listId: string;
+      task: Partial<Task> & {
+        description_yjs_state?: number[];
+        label_ids?: string[];
+        assignee_ids?: string[];
+        project_ids?: string[];
+      };
+    }) => {
+      if (!wsId) {
+        throw new Error('Workspace ID is required to create tasks');
+      }
+      if (!task.name?.trim()) {
+        throw new Error('Task name is required');
+      }
+
+      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: task.total_duration ?? null,
+          is_splittable: task.is_splittable ?? null,
+          min_split_duration_minutes: task.min_split_duration_minutes ?? null,
+          max_split_duration_minutes: task.max_split_duration_minutes ?? null,
+          calendar_hours: task.calendar_hours ?? null,
+          auto_schedule: task.auto_schedule ?? null,
+        },
+        getBrowserApiOptions()
+      );
+
+      return createdTask as Task;
+    },
+    onMutate: async ({ listId, task }) => {
+      await queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
+
+      const previousTasks = queryClient.getQueryData(['tasks', boardId]);
+      const trimmedName = task.name?.trim() ?? '';
+
+      const optimisticTask: Task = {
+        ...task,
+        id: `temp-${Date.now()}`,
+        name: trimmedName,
+        list_id: listId,
+        closed_at: undefined,
+        deleted_at: undefined,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        assignees: [],
+      } as Task;
+
+      queryClient.setQueryData(
+        ['tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return [optimisticTask];
+          return [...old, optimisticTask];
+        }
+      );
+
+      return { previousTasks, optimisticTask };
+    },
+    onError: (err, _, context) => {
+      if (context?.previousTasks) {
+        queryClient.setQueryData(['tasks', boardId], context.previousTasks);
+      } else if (context?.optimisticTask) {
+        queryClient.setQueryData(
+          ['tasks', boardId],
+          (old: Task[] | undefined) => {
+            if (!old) return old;
+            const nextTasks = old.filter(
+              (task) => task.id !== context.optimisticTask.id
+            );
+            return nextTasks.length > 0 ? nextTasks : undefined;
+          }
+        );
+      }
+
+      console.error('Failed to create task:', err);
+    },
+    onSuccess: (newTask, _, context) => {
+      queryClient.setQueryData(
+        ['tasks', boardId],
+        (old: Task[] | undefined) => {
+          const optimisticTaskId = context?.optimisticTask.id;
+
+          if (!old) return [newTask];
+
+          const nextTasks = optimisticTaskId
+            ? old.map((task) => (task.id === optimisticTaskId ? newTask : task))
+            : [...old];
+
+          if (nextTasks.some((task) => task.id === newTask.id)) {
+            return nextTasks;
+          }
+
+          return [...nextTasks, newTask];
+        }
+      );
+    },
+  });
+}
+
+export function useDeleteTask(boardId: string, wsId?: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (taskId: string) => {
+      if (!wsId) {
+        throw new Error('Workspace ID is required to delete tasks');
+      }
+      const { task } = await updateWorkspaceTask(
+        wsId,
+        taskId,
+        { deleted: true },
+        getBrowserApiOptions()
+      );
+      return task as Task;
+    },
+    onMutate: async (taskId) => {
+      await queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
+      await queryClient.cancelQueries({ queryKey: ['deleted-tasks', boardId] });
+
+      const previousTasks = queryClient.getQueryData(['tasks', boardId]) as
+        | Task[]
+        | undefined;
+      const previousDeletedTasks = queryClient.getQueryData([
+        'deleted-tasks',
+        boardId,
+      ]) as Task[] | undefined;
+
+      const deletedTask = previousTasks?.find((task) => task.id === taskId);
+
+      queryClient.setQueryData(
+        ['tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return old;
+          return old.filter((task) => task.id !== taskId);
+        }
+      );
+
+      if (deletedTask) {
+        queryClient.setQueryData(
+          ['deleted-tasks', boardId],
+          (old: Task[] | undefined) => {
+            const taskWithDeletedAt = {
+              ...deletedTask,
+              deleted_at: new Date().toISOString(),
+            };
+            if (!old) return [taskWithDeletedAt];
+            return [taskWithDeletedAt, ...old];
+          }
+        );
+      }
+
+      return { previousTasks, previousDeletedTasks, deletedTask };
+    },
+    onError: (err, _, context) => {
+      if (context?.previousTasks) {
+        queryClient.setQueryData(['tasks', boardId], context.previousTasks);
+      }
+      if (context?.previousDeletedTasks) {
+        queryClient.setQueryData(
+          ['deleted-tasks', boardId],
+          context.previousDeletedTasks
+        );
+      } else if (context?.deletedTask) {
+        const deletedTaskId = context.deletedTask.id;
+        queryClient.setQueryData(
+          ['deleted-tasks', boardId],
+          (old: Task[] | undefined) => {
+            if (!old) return old;
+            const nextTasks = old.filter((task) => task.id !== deletedTaskId);
+            return nextTasks.length > 0 ? nextTasks : undefined;
+          }
+        );
+      }
+
+      console.error('Failed to delete task:', err);
+    },
+    onSuccess: (deletedTask) => {
+      queryClient.setQueryData(
+        ['tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return old;
+          const nextTasks = old.filter((task) => task.id !== deletedTask.id);
+          return nextTasks.length > 0 ? nextTasks : undefined;
+        }
+      );
+
+      queryClient.setQueryData(
+        ['deleted-tasks', boardId],
+        (old: Task[] | undefined) => {
+          if (!old) return [deletedTask];
+
+          const existingIndex = old.findIndex(
+            (task) => task.id === deletedTask.id
+          );
+          if (existingIndex === -1) {
+            return [deletedTask, ...old];
+          }
+
+          return old.map((task) =>
+            task.id === deletedTask.id ? deletedTask : task
+          );
+        }
+      );
+    },
+  });
+}