@tuturuuu/utils 0.0.2 → 0.6.0

package/src/task/reorder.ts

@@ -0,0 +1,245 @@
+import {
+  type QueryClient,
+  useMutation,
+  useQueryClient,
+} from '@tanstack/react-query';
+import {
+  getWorkspaceTaskRelationships,
+  updateWorkspaceTask,
+} from '@tuturuuu/internal-api/tasks';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
+import {
+  isTaskBoardCompletedStatus,
+  isTaskBoardResolvedStatus,
+  isTaskBoardTerminalStatus,
+} from '../task-list-status';
+import { transformTaskRecord } from './transformers';
+
+type ReorderTaskCacheInput = {
+  taskId: string;
+  newListId: string;
+  newSortKey: number;
+  targetListStatus?: TaskList['status'] | null;
+  localMutationAt?: number;
+};
+
+type LocallyMutatedTask = Task & { _localMutationAt: number };
+type ReorderTaskMutationInput = {
+  taskId: string;
+  newListId: string;
+  newSortKey: number;
+  optimisticPreviousTasks?: Task[];
+  optimisticPreviousFullTasks?: Task[];
+};
+
+export function mergeOptimisticReorderedTaskIntoCache(
+  tasks: Task[] | undefined,
+  {
+    taskId,
+    newListId,
+    newSortKey,
+    targetListStatus,
+    localMutationAt = Date.now(),
+  }: ReorderTaskCacheInput
+) {
+  if (!tasks) return tasks;
+
+  const targetIsCompleted = isTaskBoardCompletedStatus(targetListStatus);
+  const targetIsTerminal = isTaskBoardTerminalStatus(targetListStatus);
+  const mutationTimestamp = new Date(localMutationAt).toISOString();
+
+  return tasks.map((task) => {
+    if (task.id !== taskId) return task;
+
+    return {
+      ...task,
+      list_id: newListId,
+      sort_key: newSortKey,
+      completed: targetIsCompleted,
+      completed_at: targetIsCompleted
+        ? (task.completed_at ?? mutationTimestamp)
+        : null,
+      closed_at: targetIsTerminal
+        ? (task.closed_at ?? mutationTimestamp)
+        : null,
+      _localMutationAt: localMutationAt,
+    } as LocallyMutatedTask;
+  });
+}
+
+export function mergeServerReorderedTaskIntoCache(
+  tasks: Task[] | undefined,
+  updatedTask: Task,
+  localMutationAt = Date.now()
+) {
+  if (!tasks) return tasks;
+
+  return tasks.map((task) => {
+    if (task.id !== updatedTask.id) return task;
+
+    return {
+      ...task,
+      ...updatedTask,
+      _localMutationAt: localMutationAt,
+    } as LocallyMutatedTask;
+  });
+}
+
+function setReorderedTaskCache(
+  queryClient: QueryClient,
+  boardId: string,
+  updater: (tasks: Task[] | undefined) => Task[] | undefined
+) {
+  queryClient.setQueryData(['tasks', boardId], updater);
+
+  if (queryClient.getQueryData<Task[]>(['tasks-full', boardId])) {
+    queryClient.setQueryData(['tasks-full', boardId], updater);
+  }
+}
+
+// Reorder task within the same list or move to a different list with specific position
+export async function reorderTask(
+  wsId: string,
+  taskId: string,
+  newListId: string,
+  newSortKey: number
+): Promise<Task> {
+  const baseUrl =
+    typeof window !== 'undefined' ? window.location.origin : undefined;
+
+  const { task } = await updateWorkspaceTask(
+    wsId,
+    taskId,
+    {
+      list_id: newListId,
+      sort_key: newSortKey,
+    },
+    baseUrl ? { baseUrl } : undefined
+  );
+
+  return transformTaskRecord(task) as Task;
+}
+
+// React Query hook for reordering tasks
+export function useReorderTask(boardId: string, wsId: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      taskId,
+      newListId,
+      newSortKey,
+    }: ReorderTaskMutationInput) => {
+      return reorderTask(wsId, taskId, newListId, newSortKey);
+    },
+    onMutate: ({
+      taskId,
+      newListId,
+      newSortKey,
+      optimisticPreviousTasks,
+      optimisticPreviousFullTasks,
+    }) => {
+      // Snapshot the previous value
+      const previousTasks = queryClient.getQueryData<Task[]>([
+        'tasks',
+        boardId,
+      ]);
+      const previousFullTasks = queryClient.getQueryData<Task[]>([
+        'tasks-full',
+        boardId,
+      ]);
+
+      // Cancel any outgoing refetches without delaying the optimistic landing.
+      void queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
+
+      // Check if moving to a done or closed list
+      const targetList = queryClient.getQueryData(['task_lists', boardId]) as
+        | TaskList[]
+        | undefined;
+      const list = targetList?.find((l) => l.id === newListId);
+      const isCompletionList = isTaskBoardResolvedStatus(list?.status);
+
+      // If moving to completion list, start fetching blocked task IDs asynchronously
+      // Don't await here to avoid blocking the optimistic update
+      let blockedTaskIdsPromise: Promise<string[]> | null = null;
+      if (isCompletionList) {
+        const baseUrl =
+          typeof window !== 'undefined' ? window.location.origin : undefined;
+        blockedTaskIdsPromise = Promise.resolve(
+          getWorkspaceTaskRelationships(
+            wsId,
+            taskId,
+            baseUrl ? { baseUrl } : undefined
+          )
+        )
+          .then((relationships) =>
+            (relationships?.blocking ?? []).map((task) => task.id)
+          )
+          .catch((err: unknown) => {
+            console.error('Failed to fetch blocked task IDs:', err);
+            return []; // Return empty array on error to prevent breaking the flow
+          });
+      }
+
+      // Optimistically update the task immediately (not blocked by the fetch above)
+      setReorderedTaskCache(queryClient, boardId, (old) =>
+        mergeOptimisticReorderedTaskIntoCache(old, {
+          taskId,
+          newListId,
+          newSortKey,
+          targetListStatus: list?.status,
+        })
+      );
+
+      return {
+        previousTasks: optimisticPreviousTasks ?? previousTasks,
+        previousFullTasks: optimisticPreviousFullTasks ?? previousFullTasks,
+        blockedTaskIdsPromise,
+      };
+    },
+    onError: (err, _, context) => {
+      if (context?.previousTasks) {
+        queryClient.setQueryData(['tasks', boardId], context.previousTasks);
+      }
+      if (context?.previousFullTasks) {
+        queryClient.setQueryData(
+          ['tasks-full', boardId],
+          context.previousFullTasks
+        );
+      }
+
+      console.error('Failed to reorder task:', err);
+    },
+    onSuccess: async (updatedTask, variables, context) => {
+      // Update the cache with the server response
+      setReorderedTaskCache(queryClient, boardId, (old) =>
+        mergeServerReorderedTaskIntoCache(old, updatedTask)
+      );
+
+      // If task was moved to done/closed list (has completed_at or closed_at set),
+      // invalidate task relationships to reflect removed blocking relationships
+      if (updatedTask.completed_at || updatedTask.closed_at) {
+        // Invalidate the completed/closed task's relationships
+        await queryClient.invalidateQueries({
+          queryKey: ['task-relationships', variables.taskId],
+        });
+
+        // Await the blockedTaskIdsPromise to get the list of blocked tasks
+        // Then invalidate all blocked tasks' relationships (they're now unblocked)
+        if (context?.blockedTaskIdsPromise) {
+          const blockedTaskIds = await context.blockedTaskIdsPromise;
+          if (blockedTaskIds.length > 0) {
+            await Promise.all(
+              blockedTaskIds.map((blockedTaskId) =>
+                queryClient.invalidateQueries({
+                  queryKey: ['task-relationships', blockedTaskId],
+                })
+              )
+            );
+          }
+        }
+      }
+    },
+  });
+}

package/src/task/transformers.ts

@@ -0,0 +1,149 @@
+import type { Task, TaskAssignee } from '@tuturuuu/types/primitives/Task';
+import type { User } from '@tuturuuu/types/primitives/User';
+
+type TaskUser = NonNullable<Task['assignees']>[number];
+type TaskLabel = NonNullable<Task['labels']>[number];
+type TaskProject = NonNullable<Task['projects']>[number];
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function normalizeTaskUser(
+  assignee: (TaskAssignee & { user: User }) | TaskUser | null | undefined
+): (TaskUser & { user_id: string }) | null {
+  if (!assignee) {
+    return null;
+  }
+
+  const expandedUser =
+    'user' in assignee && assignee.user && typeof assignee.user === 'object'
+      ? assignee.user
+      : null;
+
+  const effectiveUserId =
+    expandedUser?.id ??
+    ('user_id' in assignee && typeof assignee.user_id === 'string'
+      ? assignee.user_id
+      : undefined) ??
+    ('id' in assignee && typeof assignee.id === 'string'
+      ? assignee.id
+      : undefined);
+
+  if (!effectiveUserId) {
+    return null;
+  }
+
+  const displayName =
+    expandedUser?.display_name ??
+    ('display_name' in assignee && typeof assignee.display_name === 'string'
+      ? assignee.display_name
+      : undefined);
+  const email =
+    expandedUser?.email ??
+    ('email' in assignee && typeof assignee.email === 'string'
+      ? assignee.email
+      : undefined);
+  const avatarUrl =
+    expandedUser?.avatar_url ??
+    ('avatar_url' in assignee && typeof assignee.avatar_url === 'string'
+      ? assignee.avatar_url
+      : undefined);
+  const handle =
+    expandedUser?.handle ??
+    ('handle' in assignee && typeof assignee.handle === 'string'
+      ? assignee.handle
+      : undefined);
+
+  return {
+    id: effectiveUserId,
+    ...(displayName ? { display_name: displayName } : {}),
+    ...(email ? { email } : {}),
+    ...(avatarUrl ? { avatar_url: avatarUrl } : {}),
+    ...(handle ? { handle } : {}),
+    user_id: effectiveUserId,
+  };
+}
+
+export function transformAssignees(
+  assignees:
+    | Array<(TaskAssignee & { user: User }) | TaskUser>
+    | null
+    | undefined
+): (TaskUser & { user_id: string })[] {
+  return (
+    assignees
+      ?.map((assignee) => normalizeTaskUser(assignee))
+      .filter((user): user is TaskUser & { user_id: string } =>
+        Boolean(user?.id)
+      )
+      .filter(
+        (user, index: number, self) =>
+          self.findIndex((u) => u.id === user.id) === index
+      ) || []
+  );
+}
+
+function normalizeLabels(labels: unknown): TaskLabel[] {
+  if (!Array.isArray(labels)) {
+    return [];
+  }
+
+  return labels
+    .map((entry): TaskLabel | null => {
+      if (!isObject(entry)) {
+        return null;
+      }
+
+      if ('label' in entry && isObject(entry.label) && 'id' in entry.label) {
+        return entry.label as TaskLabel;
+      }
+
+      if ('id' in entry) {
+        return entry as TaskLabel;
+      }
+
+      return null;
+    })
+    .filter((label): label is TaskLabel => Boolean(label?.id));
+}
+
+function normalizeProjects(projects: unknown): TaskProject[] {
+  if (!Array.isArray(projects)) {
+    return [];
+  }
+
+  return projects
+    .map((entry): TaskProject | null => {
+      if (!isObject(entry)) {
+        return null;
+      }
+
+      if (
+        'project' in entry &&
+        isObject(entry.project) &&
+        'id' in entry.project
+      ) {
+        return entry.project as TaskProject;
+      }
+
+      if ('id' in entry) {
+        return entry as TaskProject;
+      }
+
+      return null;
+    })
+    .filter((project): project is TaskProject => Boolean(project?.id));
+}
+
+export function transformTaskRecord(task: any): Task {
+  const normalizedLabels = normalizeLabels(task.labels);
+  const normalizedProjects = normalizeProjects(task.projects);
+
+  return {
+    ...task,
+    assignees: transformAssignees(task.assignees),
+    labels: normalizedLabels,
+    projects: normalizedProjects,
+  } as Task;
+}

package/src/task-date-timezone.ts

@@ -0,0 +1,133 @@
+/**
+ * Task date/time helpers that respect a user-configured timezone.
+ * Used when creating or updating task start_date/end_date so stored UTC
+ * corresponds to the intended local date and time in the user's timezone.
+ */
+
+import dayjs from 'dayjs';
+import timezone from 'dayjs/plugin/timezone';
+import utc from 'dayjs/plugin/utc';
+import { resolveAutoTimezone } from './timezone';
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+
+/**
+ * Resolves timezone for task dates: 'auto' → browser, otherwise validated IANA or UTC.
+ */
+export function resolveTaskTimezone(timezoneSetting?: string | null): string {
+  return resolveAutoTimezone(timezoneSetting);
+}
+
+/**
+ * Builds a Date representing the given local date/time in the specified timezone.
+ * Use this when the user selects a date and time in the UI (e.g. picker) so the
+ * resulting instant is correct for that timezone.
+ *
+ * @param year - Full year
+ * @param month - Month 1–12 (calendar month)
+ * @param day - Day of month
+ * @param hour - Hour 0–23
+ * @param minute - Minute 0–59
+ * @param tz - IANA timezone (e.g. 'America/New_York') or 'auto' for browser
+ */
+export function buildDateInTimezone(
+  year: number,
+  month: number,
+  day: number,
+  hour: number,
+  minute: number,
+  tz: string
+): Date {
+  const resolved = resolveTaskTimezone(tz);
+  const s = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')} ${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}:00`;
+  return dayjs.tz(s, resolved).toDate();
+}
+
+/**
+ * Returns date parts (year, month, day, hour, minute) of the given instant
+ * in the specified timezone. Useful for displaying a UTC date in user TZ
+ * or for re-building the same instant from picker date parts.
+ */
+export function getDatePartsInTimezone(
+  date: Date,
+  tz: string
+): { year: number; month: number; day: number; hour: number; minute: number } {
+  const resolved = resolveTaskTimezone(tz);
+  const d = dayjs(date).tz(resolved);
+  return {
+    year: d.year(),
+    month: d.month() + 1,
+    day: d.date(),
+    hour: d.hour(),
+    minute: d.minute(),
+  };
+}
+
+/**
+ * Converts a Date to UTC ISO string, treating the date's local calendar/time
+ * as being in the given timezone. Use when you have a Date built from local
+ * input (e.g. picker in browser local) and want to store "this date/time in
+ * user's configured timezone" as UTC.
+ *
+ * @param date - Date (typically from a picker; its getFullYear/getMonth/etc. are in browser local)
+ * @param tz - User/workspace timezone
+ * @returns ISO string in UTC for storage
+ */
+export function dateInTimezoneToUTCISO(date: Date, tz: string): string {
+  const resolved = resolveTaskTimezone(tz);
+  const y = date.getFullYear();
+  const m = date.getMonth() + 1;
+  const d = date.getDate();
+  const h = date.getHours();
+  const min = date.getMinutes();
+  const s = `${y}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')} ${String(h).padStart(2, '0')}:${String(min).padStart(2, '0')}:00`;
+  return dayjs.tz(s, resolved).toISOString();
+}
+
+/**
+ * Formats a UTC instant (Date or ISO string) in the given timezone for display.
+ */
+export function formatInTimezone(
+  date: Date | string,
+  tz: string,
+  formatStr: string
+): string {
+  const resolved = resolveTaskTimezone(tz);
+  const d = dayjs(date).tz(resolved);
+  return d.format(formatStr);
+}
+
+const DATE_ONLY_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+const HAS_UTC_OFFSET = /[Zz+-]\d{2}:?\d{2}$|[Zz]$/;
+
+/**
+ * Parses a date string from the AI (e.g. "2025-02-23" or "2025-02-23T15:00:00")
+ * and returns UTC ISO string. When the string has no timezone (date-only or
+ * naive datetime), interprets it in the user's timezone.
+ *
+ * @param dateStr - ISO date or date-only YYYY-MM-DD
+ * @param tz - User/workspace IANA timezone
+ * @param endOfDay - If true and dateStr is date-only, use 23:59:59.999 in tz; else 00:00:00
+ */
+export function parseTaskDateToUTCISO(
+  dateStr: string,
+  tz: string,
+  endOfDay: boolean
+): string {
+  const trimmed = dateStr.trim();
+  if (HAS_UTC_OFFSET.test(trimmed)) {
+    return dayjs.utc(trimmed).toISOString();
+  }
+  const resolved = resolveTaskTimezone(tz);
+  if (DATE_ONLY_REGEX.test(trimmed)) {
+    const d = dayjs.tz(trimmed, resolved);
+    const anchored = endOfDay ? d.endOf('day') : d.startOf('day');
+    return anchored.toISOString();
+  }
+  const d = dayjs.tz(trimmed, resolved);
+  if (!d.isValid()) {
+    return dayjs.utc(trimmed).toISOString();
+  }
+  return d.toISOString();
+}