@tuturuuu/ui 0.0.4 → 0.1.0

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/use-task-dependencies.ts

@@ -0,0 +1,773 @@
+'use client';
+
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { getWorkspaceTaskRelationships } from '@tuturuuu/internal-api/tasks';
+import type {
+  RelatedTaskInfo,
+  TaskRelationshipsResponse,
+} from '@tuturuuu/types/primitives/TaskRelationship';
+import { toast } from '@tuturuuu/ui/sonner';
+import {
+  TaskRelationshipError,
+  useCreateTaskRelationship,
+  useCreateTaskWithRelationship,
+  useDeleteTaskRelationship,
+} from '@tuturuuu/utils/task-helper';
+import { useTranslations } from 'next-intl';
+import { useCallback, useState } from 'react';
+import {
+  getActiveBroadcast,
+  useBoardBroadcast,
+} from '../../board-broadcast-context';
+import type { PendingTaskRelationships } from '../types/pending-relationship';
+
+export interface UseTaskDependenciesProps {
+  taskId?: string;
+  boardId: string;
+  wsId: string;
+  listId?: string;
+  isCreateMode: boolean;
+  initialPendingRelationships?: PendingTaskRelationships;
+  onUpdate?: () => void;
+}
+
+export interface UseTaskDependenciesReturn {
+  // Data
+  relationships: TaskRelationshipsResponse | null | undefined;
+  isLoading: boolean;
+
+  // Parent task
+  parentTask: RelatedTaskInfo | null;
+  setParentTask: (task: RelatedTaskInfo | null) => Promise<void>;
+  createParentTask: (name: string) => Promise<void>;
+
+  // Child tasks
+  childTasks: RelatedTaskInfo[];
+  addChildTask: (task: RelatedTaskInfo) => Promise<void>;
+  removeChildTask: (taskId: string) => Promise<void>;
+
+  // Blocking relationships
+  blocking: RelatedTaskInfo[];
+  addBlockingTask: (task: RelatedTaskInfo) => Promise<void>;
+  removeBlockingTask: (taskId: string) => Promise<void>;
+  createBlockingTask: (name: string) => Promise<void>;
+
+  // Blocked by relationships
+  blockedBy: RelatedTaskInfo[];
+  addBlockedByTask: (task: RelatedTaskInfo) => Promise<void>;
+  removeBlockedByTask: (taskId: string) => Promise<void>;
+  createBlockedByTask: (name: string) => Promise<void>;
+
+  // Related tasks
+  relatedTasks: RelatedTaskInfo[];
+  addRelatedTask: (task: RelatedTaskInfo) => Promise<void>;
+  removeRelatedTask: (taskId: string) => Promise<void>;
+  createRelatedTask: (name: string) => Promise<void>;
+
+  // Loading states
+  savingRelationship: string | null;
+  pendingRelationships: PendingTaskRelationships;
+}
+
+function dedupeTasksById(tasks: RelatedTaskInfo[]): RelatedTaskInfo[] {
+  const seen = new Set<string>();
+  return tasks.filter((task) => {
+    if (!task.id || seen.has(task.id)) {
+      return false;
+    }
+    seen.add(task.id);
+    return true;
+  });
+}
+
+/**
+ * Custom hook for managing task dependencies/relationships
+ * Handles parent-child, blocking, blocked-by, and related task relationships
+ */
+export function useTaskDependencies({
+  taskId,
+  boardId,
+  wsId,
+  listId,
+  isCreateMode,
+  initialPendingRelationships,
+  onUpdate,
+}: UseTaskDependenciesProps): UseTaskDependenciesReturn {
+  const queryClient = useQueryClient();
+  const tc = useTranslations('common');
+  const contextBroadcast = useBoardBroadcast();
+  const broadcast = contextBroadcast ?? getActiveBroadcast();
+
+  const [savingRelationship, setSavingRelationship] = useState<string | null>(
+    null
+  );
+
+  // Pending relationships for create mode (not yet saved to DB)
+  const [pendingParent, setPendingParent] = useState<RelatedTaskInfo | null>(
+    initialPendingRelationships?.parentTask ?? null
+  );
+  const [pendingChildren, setPendingChildren] = useState<RelatedTaskInfo[]>(
+    () => dedupeTasksById(initialPendingRelationships?.childTasks ?? [])
+  );
+  const [pendingBlocking, setPendingBlocking] = useState<RelatedTaskInfo[]>(
+    () => dedupeTasksById(initialPendingRelationships?.blockingTasks ?? [])
+  );
+  const [pendingBlockedBy, setPendingBlockedBy] = useState<RelatedTaskInfo[]>(
+    () => dedupeTasksById(initialPendingRelationships?.blockedByTasks ?? [])
+  );
+  const [pendingRelated, setPendingRelated] = useState<RelatedTaskInfo[]>(() =>
+    dedupeTasksById(initialPendingRelationships?.relatedTasks ?? [])
+  );
+
+  // Fetch relationships from server
+  const { data: relationships, isLoading } = useQuery({
+    queryKey: ['task-relationships', taskId, wsId],
+    queryFn: async (): Promise<TaskRelationshipsResponse | null> => {
+      if (isCreateMode || !taskId || !wsId) {
+        return null;
+      }
+
+      return getWorkspaceTaskRelationships(wsId, taskId);
+    },
+    enabled: !isCreateMode && !!taskId && !!wsId,
+    staleTime: 30000,
+  });
+
+  // Mutations
+  const createRelationship = useCreateTaskRelationship(wsId);
+  const deleteRelationship = useDeleteTaskRelationship(wsId);
+  const createTaskWithRelationship = useCreateTaskWithRelationship(
+    boardId,
+    wsId
+  );
+
+  const getRelationshipErrorMessage = useCallback(
+    (error: unknown, fallback: string) => {
+      if (error instanceof TaskRelationshipError) {
+        switch (error.code) {
+          case 'already_exists':
+            return tc('task_relationship_already_exists');
+          case 'single_parent':
+            return tc('task_relationship_single_parent');
+          case 'circular':
+            return tc('task_relationship_circular');
+        }
+      }
+
+      return error instanceof Error && error.message ? error.message : fallback;
+    },
+    [tc]
+  );
+
+  // Helper to invalidate relationship caches and broadcast changes.
+  // NOTE: We intentionally do NOT invalidate ['tasks', boardId] here —
+  // the kanban board relies on realtime sync via setQueryData, and
+  // invalidating the full task list causes all tasks to disappear briefly.
+  const invalidateCaches = useCallback(
+    async (otherTaskId?: string) => {
+      await Promise.all([
+        taskId &&
+          queryClient.invalidateQueries({
+            queryKey: ['task-relationships', taskId, wsId],
+          }),
+        otherTaskId &&
+          queryClient.invalidateQueries({
+            queryKey: ['task-relationships', otherTaskId, wsId],
+          }),
+      ]);
+
+      // Broadcast dependency changes to other clients
+      const ids = [taskId, otherTaskId].filter(Boolean) as string[];
+      if (ids.length > 0) {
+        broadcast?.('task:deps-changed', { taskIds: ids });
+      }
+
+      onUpdate?.();
+    },
+    [taskId, wsId, queryClient, onUpdate, broadcast]
+  );
+
+  // =========================================================================
+  // Parent Task Operations
+  // =========================================================================
+
+  const setParentTask = useCallback(
+    async (task: RelatedTaskInfo | null) => {
+      if (isCreateMode) {
+        setPendingParent(task);
+        return;
+      }
+
+      if (!taskId) return;
+
+      setSavingRelationship('parent');
+      try {
+        // If we already have a parent, remove it first
+        if (relationships?.parentTask) {
+          await deleteRelationship.mutateAsync({
+            sourceTaskId: relationships.parentTask.id,
+            targetTaskId: taskId,
+            type: 'parent_child',
+          });
+        }
+
+        // If setting a new parent, create the relationship
+        if (task) {
+          await createRelationship.mutateAsync({
+            source_task_id: task.id, // Parent is source
+            target_task_id: taskId, // This task is child
+            type: 'parent_child',
+          });
+          toast.success(
+            `Parent set: This task is now a sub-task of "${task.name}"`
+          );
+        } else {
+          toast.success('Parent removed: This task is no longer a sub-task');
+        }
+
+        await invalidateCaches(task?.id);
+      } catch (e) {
+        const message = getRelationshipErrorMessage(
+          e,
+          'Unable to update parent task'
+        );
+        toast.error(`Failed to update parent: ${message}`);
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [
+      isCreateMode,
+      taskId,
+      relationships?.parentTask,
+      deleteRelationship,
+      createRelationship,
+      invalidateCaches,
+      getRelationshipErrorMessage,
+    ]
+  );
+
+  /**
+   * Create a new task and set it as the parent of the current task
+   */
+  const createParentTask = useCallback(
+    async (name: string) => {
+      if (isCreateMode || !taskId || !listId) {
+        toast.error('Cannot create parent task: Task must be saved first');
+        return;
+      }
+
+      setSavingRelationship('create-parent');
+      try {
+        // If we already have a parent, remove it first
+        if (relationships?.parentTask) {
+          await deleteRelationship.mutateAsync({
+            sourceTaskId: relationships.parentTask.id,
+            targetTaskId: taskId,
+            type: 'parent_child',
+          });
+        }
+
+        // Create new parent task + relationship
+        const result = await createTaskWithRelationship.mutateAsync({
+          name,
+          listId,
+          currentTaskId: taskId,
+          relationshipType: 'parent_child',
+          currentTaskIsSource: false, // New task (parent) is source, current task is target (child)
+        });
+
+        toast.success(
+          `Parent task created: "${name}" is now the parent of this task`
+        );
+
+        await invalidateCaches(result.task.id);
+      } catch (e: any) {
+        toast.error(
+          `Failed to create parent task: ${e.message || 'Unable to create parent task'}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [
+      isCreateMode,
+      taskId,
+      listId,
+      relationships?.parentTask,
+      deleteRelationship,
+      createTaskWithRelationship,
+      invalidateCaches,
+    ]
+  );
+
+  // =========================================================================
+  // Child Task Operations
+  // =========================================================================
+
+  const addChildTask = useCallback(
+    async (task: RelatedTaskInfo) => {
+      if (isCreateMode) {
+        setPendingChildren((prev) => dedupeTasksById([...prev, task]));
+        return;
+      }
+
+      if (!taskId) return;
+
+      setSavingRelationship(`child-${task.id}`);
+      try {
+        await createRelationship.mutateAsync({
+          source_task_id: taskId, // This task is parent
+          target_task_id: task.id, // Selected task is child
+          type: 'parent_child',
+        });
+        toast.success(`Sub-task added: "${task.name}" is now a sub-task`);
+        await invalidateCaches(task.id);
+      } catch (e: any) {
+        toast.error(
+          `Failed to add sub-task: ${getRelationshipErrorMessage(
+            e,
+            'Unable to add sub-task'
+          )}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [
+      isCreateMode,
+      taskId,
+      createRelationship,
+      invalidateCaches,
+      getRelationshipErrorMessage,
+    ]
+  );
+
+  const removeChildTask = useCallback(
+    async (childTaskId: string) => {
+      if (isCreateMode) {
+        setPendingChildren((prev) => prev.filter((t) => t.id !== childTaskId));
+        return;
+      }
+
+      if (!taskId) return;
+
+      setSavingRelationship(`child-${childTaskId}`);
+      try {
+        await deleteRelationship.mutateAsync({
+          sourceTaskId: taskId, // This task is parent
+          targetTaskId: childTaskId, // The child being removed
+          type: 'parent_child',
+        });
+        toast.success('Sub-task removed: Task is no longer a sub-task');
+        await invalidateCaches(childTaskId);
+      } catch (e: any) {
+        toast.error(
+          `Failed to remove sub-task: ${e.message || 'Unable to remove sub-task'}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [isCreateMode, taskId, deleteRelationship, invalidateCaches]
+  );
+
+  // =========================================================================
+  // Blocking Task Operations (this task blocks others)
+  // =========================================================================
+
+  const addBlockingTask = useCallback(
+    async (task: RelatedTaskInfo) => {
+      if (isCreateMode) {
+        setPendingBlocking((prev) => dedupeTasksById([...prev, task]));
+        return;
+      }
+
+      if (!taskId) return;
+
+      setSavingRelationship(`blocking-${task.id}`);
+      try {
+        await createRelationship.mutateAsync({
+          source_task_id: taskId, // This task blocks
+          target_task_id: task.id, // The blocked task
+          type: 'blocks',
+        });
+        toast.success(
+          `Blocking relationship added: This task now blocks "${task.name}"`
+        );
+        await invalidateCaches(task.id);
+      } catch (e: any) {
+        toast.error(
+          `Failed to add blocking relationship: ${getRelationshipErrorMessage(
+            e,
+            'Unable to add blocking relationship'
+          )}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [
+      isCreateMode,
+      taskId,
+      createRelationship,
+      invalidateCaches,
+      getRelationshipErrorMessage,
+    ]
+  );
+
+  const removeBlockingTask = useCallback(
+    async (blockedTaskId: string) => {
+      if (isCreateMode) {
+        setPendingBlocking((prev) =>
+          prev.filter((t) => t.id !== blockedTaskId)
+        );
+        return;
+      }
+
+      if (!taskId) return;
+
+      setSavingRelationship(`blocking-${blockedTaskId}`);
+      try {
+        await deleteRelationship.mutateAsync({
+          sourceTaskId: taskId,
+          targetTaskId: blockedTaskId,
+          type: 'blocks',
+        });
+        toast.success(
+          'Blocking relationship removed: Task is no longer blocked by this task'
+        );
+        await invalidateCaches(blockedTaskId);
+      } catch (e: any) {
+        toast.error(
+          `Failed to remove blocking relationship: ${e.message || 'Unable to remove blocking relationship'}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [isCreateMode, taskId, deleteRelationship, invalidateCaches]
+  );
+
+  /**
+   * Create a new task that this task blocks
+   */
+  const createBlockingTask = useCallback(
+    async (name: string) => {
+      if (isCreateMode || !taskId || !listId) {
+        toast.error('Cannot create task: Task must be saved first');
+        return;
+      }
+
+      setSavingRelationship('create-blocking');
+      try {
+        const result = await createTaskWithRelationship.mutateAsync({
+          name,
+          listId,
+          currentTaskId: taskId,
+          relationshipType: 'blocks',
+          currentTaskIsSource: true, // Current task blocks the new task
+        });
+
+        toast.success(`Blocking task created: This task now blocks "${name}"`);
+
+        await invalidateCaches(result.task.id);
+      } catch (e: any) {
+        toast.error(
+          `Failed to create blocking task: ${e.message || 'Unable to create task'}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [isCreateMode, taskId, listId, createTaskWithRelationship, invalidateCaches]
+  );
+
+  // =========================================================================
+  // Blocked By Task Operations (this task is blocked by others)
+  // =========================================================================
+
+  const addBlockedByTask = useCallback(
+    async (task: RelatedTaskInfo) => {
+      if (isCreateMode) {
+        setPendingBlockedBy((prev) => dedupeTasksById([...prev, task]));
+        return;
+      }
+
+      if (!taskId) return;
+
+      setSavingRelationship(`blocked-by-${task.id}`);
+      try {
+        await createRelationship.mutateAsync({
+          source_task_id: task.id, // The blocking task
+          target_task_id: taskId, // This task is blocked
+          type: 'blocks',
+        });
+        toast.success(
+          `Dependency added: This task is now blocked by "${task.name}"`
+        );
+        await invalidateCaches(task.id);
+      } catch (e: any) {
+        toast.error(
+          `Failed to add dependency: ${getRelationshipErrorMessage(
+            e,
+            'Unable to add dependency'
+          )}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [
+      isCreateMode,
+      taskId,
+      createRelationship,
+      invalidateCaches,
+      getRelationshipErrorMessage,
+    ]
+  );
+
+  const removeBlockedByTask = useCallback(
+    async (blockingTaskId: string) => {
+      if (isCreateMode) {
+        setPendingBlockedBy((prev) =>
+          prev.filter((t) => t.id !== blockingTaskId)
+        );
+        return;
+      }
+
+      if (!taskId) return;
+
+      setSavingRelationship(`blocked-by-${blockingTaskId}`);
+      try {
+        await deleteRelationship.mutateAsync({
+          sourceTaskId: blockingTaskId,
+          targetTaskId: taskId,
+          type: 'blocks',
+        });
+        toast.success('Dependency removed: This task is no longer blocked');
+        await invalidateCaches(blockingTaskId);
+      } catch (e: any) {
+        toast.error(
+          `Failed to remove dependency: ${e.message || 'Unable to remove dependency'}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [isCreateMode, taskId, deleteRelationship, invalidateCaches]
+  );
+
+  /**
+   * Create a new task that blocks this task
+   */
+  const createBlockedByTask = useCallback(
+    async (name: string) => {
+      if (isCreateMode || !taskId || !listId) {
+        toast.error('Cannot create task: Task must be saved first');
+        return;
+      }
+
+      setSavingRelationship('create-blocked-by');
+      try {
+        const result = await createTaskWithRelationship.mutateAsync({
+          name,
+          listId,
+          currentTaskId: taskId,
+          relationshipType: 'blocks',
+          currentTaskIsSource: false, // New task blocks current task (new is source)
+        });
+
+        toast.success(
+          `Blocking task created: This task is now blocked by "${name}"`
+        );
+
+        await invalidateCaches(result.task.id);
+      } catch (e: any) {
+        toast.error(
+          `Failed to create blocking task: ${e.message || 'Unable to create task'}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [isCreateMode, taskId, listId, createTaskWithRelationship, invalidateCaches]
+  );
+
+  // =========================================================================
+  // Related Task Operations
+  // =========================================================================
+
+  const addRelatedTask = useCallback(
+    async (task: RelatedTaskInfo) => {
+      if (isCreateMode) {
+        setPendingRelated((prev) => dedupeTasksById([...prev, task]));
+        return;
+      }
+
+      if (!taskId) return;
+
+      setSavingRelationship(`related-${task.id}`);
+      try {
+        await createRelationship.mutateAsync({
+          source_task_id: taskId,
+          target_task_id: task.id,
+          type: 'related',
+        });
+        toast.success(`Related task added: "${task.name}" is now linked`);
+        await invalidateCaches(task.id);
+      } catch (e: any) {
+        toast.error(
+          `Failed to add related task: ${getRelationshipErrorMessage(
+            e,
+            'Unable to add related task'
+          )}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [
+      isCreateMode,
+      taskId,
+      createRelationship,
+      invalidateCaches,
+      getRelationshipErrorMessage,
+    ]
+  );
+
+  const removeRelatedTask = useCallback(
+    async (relatedTaskId: string) => {
+      if (isCreateMode) {
+        setPendingRelated((prev) => prev.filter((t) => t.id !== relatedTaskId));
+        return;
+      }
+
+      if (!taskId) return;
+
+      setSavingRelationship(`related-${relatedTaskId}`);
+      try {
+        // Try both directions since related is bidirectional
+        await deleteRelationship.mutateAsync({
+          sourceTaskId: taskId,
+          targetTaskId: relatedTaskId,
+          type: 'related',
+        });
+        toast.success('Related task removed: Tasks are no longer linked');
+        await invalidateCaches(relatedTaskId);
+      } catch {
+        // If first direction fails, try the other
+        try {
+          await deleteRelationship.mutateAsync({
+            sourceTaskId: relatedTaskId,
+            targetTaskId: taskId,
+            type: 'related',
+          });
+          toast.success('Related task removed: Tasks are no longer linked');
+          await invalidateCaches(relatedTaskId);
+        } catch (e: any) {
+          toast.error(
+            `Failed to remove related task: ${e.message || 'Unable to remove related task'}`
+          );
+        }
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [isCreateMode, taskId, deleteRelationship, invalidateCaches]
+  );
+
+  /**
+   * Create a new task and link it as related
+   */
+  const createRelatedTask = useCallback(
+    async (name: string) => {
+      if (isCreateMode || !taskId || !listId) {
+        toast.error('Cannot create task: Task must be saved first');
+        return;
+      }
+
+      setSavingRelationship('create-related');
+      try {
+        const result = await createTaskWithRelationship.mutateAsync({
+          name,
+          listId,
+          currentTaskId: taskId,
+          relationshipType: 'related',
+          currentTaskIsSource: true, // Direction doesn't matter for related
+        });
+
+        toast.success(`Related task created: "${name}" is now linked`);
+
+        await invalidateCaches(result.task.id);
+      } catch (e: any) {
+        toast.error(
+          `Failed to create related task: ${e.message || 'Unable to create task'}`
+        );
+      } finally {
+        setSavingRelationship(null);
+      }
+    },
+    [isCreateMode, taskId, listId, createTaskWithRelationship, invalidateCaches]
+  );
+
+  // =========================================================================
+  // Computed values (merge server data with pending for create mode)
+  // =========================================================================
+
+  const parentTask = isCreateMode
+    ? pendingParent
+    : (relationships?.parentTask ?? null);
+
+  const childTasks = isCreateMode
+    ? pendingChildren
+    : (relationships?.childTasks ?? []);
+
+  const blocking = isCreateMode
+    ? pendingBlocking
+    : (relationships?.blocking ?? []);
+
+  const blockedBy = isCreateMode
+    ? pendingBlockedBy
+    : (relationships?.blockedBy ?? []);
+
+  const relatedTasks = isCreateMode
+    ? pendingRelated
+    : (relationships?.relatedTasks ?? []);
+
+  const pendingRelationships: PendingTaskRelationships = {
+    parentTask: pendingParent,
+    childTasks: pendingChildren,
+    blockingTasks: pendingBlocking,
+    blockedByTasks: pendingBlockedBy,
+    relatedTasks: pendingRelated,
+    initialActiveTab: initialPendingRelationships?.initialActiveTab,
+    initialDependencySubTab:
+      initialPendingRelationships?.initialDependencySubTab,
+  };
+
+  return {
+    relationships,
+    isLoading,
+    parentTask,
+    setParentTask,
+    createParentTask,
+    childTasks,
+    addChildTask,
+    removeChildTask,
+    blocking,
+    addBlockingTask,
+    removeBlockingTask,
+    createBlockingTask,
+    blockedBy,
+    addBlockedByTask,
+    removeBlockedByTask,
+    createBlockedByTask,
+    relatedTasks,
+    addRelatedTask,
+    removeRelatedTask,
+    createRelatedTask,
+    savingRelationship,
+    pendingRelationships,
+  };
+}