@tuturuuu/ui 0.0.4 → 0.1.0

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

@@ -0,0 +1,1450 @@
+'use client';
+
+import type { QueryClient } from '@tanstack/react-query';
+import type { Editor, JSONContent } from '@tiptap/react';
+import { updateTaskSchedulingSettings } from '@tuturuuu/internal-api';
+import type { WorkspaceTaskUpdatePayload } from '@tuturuuu/internal-api/tasks';
+import { createWorkspaceTaskRelationship } from '@tuturuuu/internal-api/tasks';
+import { createClient } from '@tuturuuu/supabase/next/client';
+import type { CalendarHoursType, Task } from '@tuturuuu/types/primitives/Task';
+import type { RelatedTaskInfo } from '@tuturuuu/types/primitives/TaskRelationship';
+import { useToast } from '@tuturuuu/ui/hooks/use-toast';
+import {
+  MAX_TASK_DESCRIPTION_LENGTH,
+  MAX_TASK_NAME_LENGTH,
+} from '@tuturuuu/utils/constants';
+import { createTask } from '@tuturuuu/utils/task-helper';
+import { convertJsonContentToYjsState } from '@tuturuuu/utils/yjs-helper';
+import { useTranslations } from 'next-intl';
+import type React from 'react';
+import { useCallback, useRef } from 'react';
+import type { BoardBroadcastFn } from '../../board-broadcast-context';
+import {
+  getActiveBroadcast,
+  useBoardBroadcast,
+} from '../../board-broadcast-context';
+import type {
+  PendingRelationship,
+  PendingTaskRelationships,
+} from '../types/pending-relationship';
+import {
+  clearDraft,
+  serializeTaskDescriptionContent,
+  updateTaskDescriptionCaches,
+} from '../utils';
+import {
+  updateWorkspaceTask,
+  updateWorkspaceTaskDescription,
+} from './task-api';
+import type {
+  SaveSchedulingSettingsOptions,
+  SchedulingSettings,
+} from './use-task-mutations';
+import { useUpdateSharedTask } from './use-update-shared-task';
+
+export interface UseTaskSaveProps {
+  // Core identifiers
+  wsId: string;
+  boardId: string;
+  taskId?: string;
+  saveAsDraft: boolean;
+  draftId?: string;
+  isCreateMode: boolean;
+  collaborationMode: boolean;
+  isPersonalWorkspace: boolean;
+  /** Present when opened via /shared/task/[shareCode] */
+  shareCode?: string;
+  /** Permission returned from shared-task API */
+  sharedPermission?: 'view' | 'edit';
+  parentTaskId?: string;
+  pendingRelationship?: PendingRelationship;
+  pendingTaskRelationships?: PendingTaskRelationships;
+  draftStorageKey: string;
+
+  // Form state
+  name: string;
+  description: JSONContent | null;
+  editorInstance: Editor | null;
+  priority: 'critical' | 'high' | 'low' | 'normal' | null;
+  startDate: Date | undefined;
+  endDate: Date | undefined;
+  selectedListId: string;
+  estimationPoints: number | null | undefined;
+  selectedLabels: Array<{
+    id: string;
+    name?: string;
+    color?: string;
+    created_at?: string;
+  }>;
+  selectedAssignees: Array<{
+    id: string;
+    user_id?: string | null;
+    display_name?: string | null;
+    avatar_url?: string | null;
+  }>;
+  selectedProjects: Array<{ id: string; name?: string; status?: string }>;
+
+  // Scheduling fields
+  totalDuration: number | null;
+  isSplittable: boolean;
+  minSplitDurationMinutes: number | null;
+  maxSplitDurationMinutes: number | null;
+  calendarHours: CalendarHoursType | null;
+  autoSchedule: boolean;
+  saveSchedulingSettings?: (
+    settings: SchedulingSettings,
+    options?: SaveSchedulingSettingsOptions
+  ) => Promise<boolean>;
+  hasUnsavedSchedulingChanges?: boolean;
+
+  // User settings
+  user: {
+    id: string;
+    display_name?: string | null;
+    avatar_url?: string | null;
+  } | null;
+  userTaskSettings?: { task_auto_assign_to_self: boolean };
+
+  // UI state
+  createMultiple: boolean;
+
+  // Refs
+  nameUpdateTimerRef: React.MutableRefObject<ReturnType<
+    typeof setTimeout
+  > | null>;
+  pendingNameRef: React.MutableRefObject<string | null>;
+  flushEditorPendingRef: React.MutableRefObject<
+    (() => JSONContent | null) | undefined
+  >;
+
+  // Callbacks
+  queryClient: QueryClient;
+  onUpdate: () => void;
+  onClose: () => void;
+
+  // State setters
+  setIsSaving: (saving: boolean) => void;
+  setIsLoading: (loading: boolean) => void;
+  setName: React.Dispatch<React.SetStateAction<string>>;
+  setDescription: React.Dispatch<React.SetStateAction<JSONContent | null>>;
+  setPriority: React.Dispatch<
+    React.SetStateAction<'critical' | 'high' | 'low' | 'normal' | null>
+  >;
+  setStartDate: React.Dispatch<React.SetStateAction<Date | undefined>>;
+  setEndDate: React.Dispatch<React.SetStateAction<Date | undefined>>;
+  setEstimationPoints: React.Dispatch<
+    React.SetStateAction<number | null | undefined>
+  >;
+  setSelectedLabels: React.Dispatch<
+    React.SetStateAction<
+      Array<{ id: string; name: string; color: string; created_at: string }>
+    >
+  >;
+  setSelectedAssignees: React.Dispatch<
+    React.SetStateAction<
+      Array<{
+        id: string;
+        user_id?: string | null;
+        display_name?: string | null;
+        avatar_url?: string | null;
+      }>
+    >
+  >;
+  setSelectedProjects: React.Dispatch<
+    React.SetStateAction<Array<{ id: string; name: string }>>
+  >;
+}
+
+export interface UseTaskSaveReturn {
+  handleSave: () => Promise<void>;
+  handleSaveRef: React.MutableRefObject<() => void>;
+}
+
+const supabase = createClient();
+const internalApiBaseUrl =
+  typeof window !== 'undefined' ? window.location.origin : undefined;
+
+export function dedupeById(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;
+  });
+}
+
+export function applyPendingRelationshipSummary({
+  boardId,
+  newTaskId,
+  queryClient,
+  pendingTaskRelationships,
+}: {
+  boardId: string;
+  newTaskId: string;
+  queryClient: QueryClient;
+  pendingTaskRelationships: PendingTaskRelationships;
+}) {
+  queryClient.setQueryData(['tasks', boardId], (old: Task[] | undefined) => {
+    if (!old) return old;
+
+    const parentTaskId = pendingTaskRelationships.parentTask?.id ?? null;
+    const newTaskSummary = old.find((task) => task.id === newTaskId);
+    const childTasks = dedupeById(pendingTaskRelationships.childTasks);
+    const blockingTasks = dedupeById(pendingTaskRelationships.blockingTasks);
+    const blockedByTasks = dedupeById(pendingTaskRelationships.blockedByTasks);
+    const relatedTasks = dedupeById(pendingTaskRelationships.relatedTasks);
+
+    return old.map((task) => {
+      const relationshipSummary = task.relationship_summary ?? {
+        parent_task_id: null,
+        parent_task: null,
+        child_count: 0,
+        completed_child_count: 0,
+        blocked_by_count: 0,
+        blocking_count: 0,
+        related_count: 0,
+      };
+
+      if (task.id === newTaskId) {
+        return {
+          ...task,
+          relationship_summary: {
+            parent_task_id: parentTaskId,
+            parent_task: pendingTaskRelationships.parentTask
+              ? {
+                  id: pendingTaskRelationships.parentTask.id,
+                  name: pendingTaskRelationships.parentTask.name,
+                  display_number:
+                    pendingTaskRelationships.parentTask.display_number ?? null,
+                  ticket_prefix:
+                    pendingTaskRelationships.parentTask.ticket_prefix ?? null,
+                }
+              : null,
+            child_count: childTasks.length,
+            completed_child_count: childTasks.filter(
+              (childTask) => childTask.completed
+            ).length,
+            blocked_by_count: blockedByTasks.length,
+            blocking_count: blockingTasks.length,
+            related_count: relatedTasks.length,
+          },
+        };
+      }
+
+      if (parentTaskId && task.id === parentTaskId) {
+        return {
+          ...task,
+          relationship_summary: {
+            ...relationshipSummary,
+            child_count: relationshipSummary.child_count + 1,
+            completed_child_count:
+              relationshipSummary.completed_child_count ?? 0,
+          },
+        };
+      }
+
+      if (childTasks.some((childTask) => childTask.id === task.id)) {
+        return {
+          ...task,
+          relationship_summary: {
+            ...relationshipSummary,
+            parent_task_id: newTaskId,
+            parent_task: {
+              id: newTaskId,
+              name: newTaskSummary?.name ?? '',
+              display_number: newTaskSummary?.display_number ?? null,
+              ticket_prefix: null,
+            },
+          },
+        };
+      }
+
+      if (blockingTasks.some((blockingTask) => blockingTask.id === task.id)) {
+        return {
+          ...task,
+          relationship_summary: {
+            ...relationshipSummary,
+            blocked_by_count: relationshipSummary.blocked_by_count + 1,
+          },
+        };
+      }
+
+      if (
+        blockedByTasks.some((blockedByTask) => blockedByTask.id === task.id)
+      ) {
+        return {
+          ...task,
+          relationship_summary: {
+            ...relationshipSummary,
+            blocking_count: relationshipSummary.blocking_count + 1,
+          },
+        };
+      }
+
+      if (relatedTasks.some((relatedTask) => relatedTask.id === task.id)) {
+        return {
+          ...task,
+          relationship_summary: {
+            ...relationshipSummary,
+            related_count: relationshipSummary.related_count + 1,
+          },
+        };
+      }
+
+      return task;
+    });
+  });
+}
+
+export function useTaskSave({
+  wsId,
+  boardId,
+  taskId,
+  saveAsDraft,
+  draftId,
+  isCreateMode,
+  collaborationMode,
+  isPersonalWorkspace,
+  shareCode,
+  sharedPermission,
+  parentTaskId,
+  pendingRelationship,
+  pendingTaskRelationships,
+  draftStorageKey,
+  name,
+  description,
+  editorInstance,
+  priority,
+  startDate,
+  endDate,
+  selectedListId,
+  estimationPoints,
+  selectedLabels,
+  selectedAssignees,
+  selectedProjects,
+  totalDuration,
+  isSplittable,
+  minSplitDurationMinutes,
+  maxSplitDurationMinutes,
+  calendarHours,
+  autoSchedule,
+  saveSchedulingSettings,
+  hasUnsavedSchedulingChanges,
+  user,
+  userTaskSettings,
+  createMultiple,
+  nameUpdateTimerRef,
+  pendingNameRef,
+  flushEditorPendingRef,
+  queryClient,
+  onUpdate,
+  onClose,
+  setIsSaving,
+  setIsLoading,
+  setName,
+  setDescription,
+  setPriority,
+  setStartDate,
+  setEndDate,
+  setEstimationPoints,
+  setSelectedLabels,
+  setSelectedAssignees,
+  setSelectedProjects,
+}: UseTaskSaveProps): UseTaskSaveReturn {
+  const { toast } = useToast();
+  const t = useTranslations('ws-task-boards.dialog');
+  const updateSharedTaskMutation = useUpdateSharedTask();
+  const contextBroadcast = useBoardBroadcast();
+  const broadcast = contextBroadcast ?? getActiveBroadcast();
+  const handleSaveRef = useRef<() => void>(() => {});
+
+  const handleSave = useCallback(async () => {
+    if (!name?.trim()) return;
+
+    // Shared task links may be view-only.
+    if (!isCreateMode && shareCode && sharedPermission !== 'edit') {
+      toast({
+        title: 'Read-only access',
+        description: 'You do not have permission to edit this task.',
+        variant: 'destructive',
+      });
+      return;
+    }
+
+    // Clear any pending name update
+    if (nameUpdateTimerRef.current) {
+      clearTimeout(nameUpdateTimerRef.current);
+      nameUpdateTimerRef.current = null;
+      pendingNameRef.current = null;
+    }
+
+    // Get current description from editor
+    let currentDescription = description;
+    if (flushEditorPendingRef.current) {
+      currentDescription = flushEditorPendingRef.current();
+    }
+
+    setIsSaving(true);
+    setIsLoading(true);
+
+    const trimmedName = name.trim();
+    const descriptionString =
+      serializeTaskDescriptionContent(currentDescription);
+    const descriptionYjsState =
+      currentDescription && editorInstance?.schema
+        ? Array.from(
+            convertJsonContentToYjsState(
+              currentDescription,
+              editorInstance.schema
+            )
+          )
+        : null;
+
+    if (trimmedName.length > MAX_TASK_NAME_LENGTH) {
+      toast({
+        title: t('title_too_long_title'),
+        description: t('title_too_long_description', {
+          max: MAX_TASK_NAME_LENGTH,
+        }),
+        variant: 'destructive',
+      });
+      setIsLoading(false);
+      setIsSaving(false);
+      return;
+    }
+
+    if (
+      descriptionString &&
+      descriptionString.length > MAX_TASK_DESCRIPTION_LENGTH
+    ) {
+      toast({
+        title: t('description_too_long_title'),
+        description: t('description_too_long_description', {
+          max: MAX_TASK_DESCRIPTION_LENGTH,
+        }),
+        variant: 'destructive',
+      });
+      setIsLoading(false);
+      setIsSaving(false);
+      return;
+    }
+
+    clearDraft(draftStorageKey);
+
+    if (isCreateMode && saveAsDraft) {
+      await handleSaveAsDraft({
+        wsId,
+        boardId,
+        draftId,
+        name: trimmedName,
+        descriptionString,
+        priority,
+        startDate,
+        endDate,
+        selectedListId,
+        estimationPoints,
+        selectedLabels,
+        selectedAssignees,
+        selectedProjects,
+        createMultiple,
+        queryClient,
+        toast,
+        onClose,
+        setIsLoading,
+        setIsSaving,
+        setName,
+        setDescription,
+        setPriority,
+        setStartDate,
+        setEndDate,
+        setEstimationPoints,
+        setSelectedLabels,
+        setSelectedAssignees,
+        setSelectedProjects,
+      });
+      return;
+    }
+
+    const schedulingSettings: SchedulingSettings = {
+      totalDuration,
+      isSplittable,
+      minSplitDurationMinutes,
+      maxSplitDurationMinutes,
+      calendarHours,
+      autoSchedule,
+    };
+
+    if (
+      !isCreateMode &&
+      hasUnsavedSchedulingChanges &&
+      saveSchedulingSettings &&
+      taskId &&
+      taskId !== 'new'
+    ) {
+      const schedulingSaved = await saveSchedulingSettings(schedulingSettings, {
+        silent: true,
+        skipRefresh: true,
+      });
+
+      if (!schedulingSaved) {
+        setIsLoading(false);
+        setIsSaving(false);
+        return;
+      }
+    }
+
+    if (isCreateMode) {
+      await handleCreateTask({
+        wsId,
+        name: trimmedName,
+        descriptionString,
+        descriptionYjsState,
+        priority,
+        startDate,
+        endDate,
+        selectedListId,
+        estimationPoints,
+        selectedLabels,
+        selectedAssignees,
+        selectedProjects,
+        totalDuration,
+        isSplittable,
+        minSplitDurationMinutes,
+        maxSplitDurationMinutes,
+        calendarHours,
+        autoSchedule,
+        parentTaskId,
+        pendingRelationship,
+        pendingTaskRelationships,
+        isPersonalWorkspace,
+        user,
+        userTaskSettings,
+        createMultiple,
+        boardId,
+        broadcast,
+        queryClient,
+        toast,
+        onUpdate,
+        onClose,
+        setIsLoading,
+        setIsSaving,
+        setName,
+        setDescription,
+        setPriority,
+        setStartDate,
+        setEndDate,
+        setEstimationPoints,
+        setSelectedLabels,
+        setSelectedAssignees,
+        setSelectedProjects,
+      });
+      return;
+    }
+
+    // Update mode
+    await handleUpdateTask({
+      taskId,
+      wsId,
+      boardId,
+      name: trimmedName,
+      descriptionString,
+      descriptionYjsState,
+      priority,
+      startDate,
+      endDate,
+      selectedListId,
+      estimationPoints,
+      collaborationMode,
+      flushEditorPendingRef,
+      updateSharedTaskMutation,
+      shareCode,
+      queryClient,
+      toast,
+      onUpdate,
+      onClose,
+      setIsLoading,
+      setIsSaving,
+    });
+  }, [
+    name,
+    description,
+    editorInstance,
+    draftStorageKey,
+    isCreateMode,
+    saveAsDraft,
+    draftId,
+    wsId,
+    priority,
+    startDate,
+    endDate,
+    estimationPoints,
+    selectedListId,
+    selectedLabels,
+    selectedAssignees,
+    selectedProjects,
+    queryClient,
+    boardId,
+    toast,
+    onUpdate,
+    createMultiple,
+    onClose,
+    taskId,
+    updateSharedTaskMutation,
+    collaborationMode,
+    setName,
+    setDescription,
+    setPriority,
+    setStartDate,
+    setEndDate,
+    setEstimationPoints,
+    setSelectedLabels,
+    setSelectedAssignees,
+    setSelectedProjects,
+    totalDuration,
+    isSplittable,
+    minSplitDurationMinutes,
+    maxSplitDurationMinutes,
+    calendarHours,
+    autoSchedule,
+    hasUnsavedSchedulingChanges,
+    saveSchedulingSettings,
+    parentTaskId,
+    pendingRelationship,
+    pendingTaskRelationships,
+    isPersonalWorkspace,
+    user,
+    userTaskSettings,
+    nameUpdateTimerRef,
+    pendingNameRef,
+    flushEditorPendingRef,
+    setIsLoading,
+    setIsSaving,
+    shareCode,
+    sharedPermission,
+    broadcast,
+    t,
+  ]);
+
+  // Keep ref updated
+  handleSaveRef.current = handleSave;
+
+  return {
+    handleSave,
+    handleSaveRef,
+  };
+}
+
+// Helper function for saving as draft
+async function handleSaveAsDraft({
+  wsId,
+  boardId,
+  draftId,
+  name,
+  descriptionString,
+  priority,
+  startDate,
+  endDate,
+  selectedListId,
+  estimationPoints,
+  selectedLabels,
+  selectedAssignees,
+  selectedProjects,
+  createMultiple,
+  queryClient,
+  toast,
+  onClose,
+  setIsLoading,
+  setIsSaving,
+  setName,
+  setDescription,
+  setPriority,
+  setStartDate,
+  setEndDate,
+  setEstimationPoints,
+  setSelectedLabels,
+  setSelectedAssignees,
+  setSelectedProjects,
+}: {
+  wsId: string;
+  boardId: string;
+  draftId?: string;
+  name: string;
+  descriptionString: string | null;
+  priority: 'critical' | 'high' | 'low' | 'normal' | null;
+  startDate: Date | undefined;
+  endDate: Date | undefined;
+  selectedListId: string;
+  estimationPoints: number | null | undefined;
+  selectedLabels: Array<{
+    id: string;
+    name?: string;
+    color?: string;
+    created_at?: string;
+  }>;
+  selectedAssignees: Array<{
+    id: string;
+    user_id?: string | null;
+    display_name?: string | null;
+    avatar_url?: string | null;
+  }>;
+  selectedProjects: Array<{ id: string; name?: string; status?: string }>;
+  createMultiple: boolean;
+  queryClient: QueryClient;
+  toast: ReturnType<typeof useToast>['toast'];
+  onClose: () => void;
+  setIsLoading: (loading: boolean) => void;
+  setIsSaving: (saving: boolean) => void;
+  setName: React.Dispatch<React.SetStateAction<string>>;
+  setDescription: React.Dispatch<React.SetStateAction<JSONContent | null>>;
+  setPriority: React.Dispatch<
+    React.SetStateAction<'critical' | 'high' | 'low' | 'normal' | null>
+  >;
+  setStartDate: React.Dispatch<React.SetStateAction<Date | undefined>>;
+  setEndDate: React.Dispatch<React.SetStateAction<Date | undefined>>;
+  setEstimationPoints: React.Dispatch<
+    React.SetStateAction<number | null | undefined>
+  >;
+  setSelectedLabels: React.Dispatch<
+    React.SetStateAction<
+      Array<{ id: string; name: string; color: string; created_at: string }>
+    >
+  >;
+  setSelectedAssignees: React.Dispatch<
+    React.SetStateAction<
+      Array<{
+        id: string;
+        user_id?: string | null;
+        display_name?: string | null;
+        avatar_url?: string | null;
+      }>
+    >
+  >;
+  setSelectedProjects: React.Dispatch<
+    React.SetStateAction<Array<{ id: string; name: string }>>
+  >;
+}) {
+  try {
+    const draftPayload = {
+      name: name.trim(),
+      description: descriptionString || null,
+      priority: priority || null,
+      board_id: boardId || null,
+      list_id: selectedListId || null,
+      start_date: startDate ? startDate.toISOString() : null,
+      end_date: endDate ? endDate.toISOString() : null,
+      estimation_points: estimationPoints ?? null,
+      label_ids: selectedLabels.map((l) => l.id),
+      assignee_ids: selectedAssignees.map((a) => a.user_id || a.id),
+      project_ids: selectedProjects.map((p) => p.id),
+    };
+
+    const url = draftId
+      ? `/api/v1/workspaces/${wsId}/task-drafts/${draftId}`
+      : `/api/v1/workspaces/${wsId}/task-drafts`;
+
+    const res = await fetch(url, {
+      method: draftId ? 'PUT' : 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(draftPayload),
+    });
+
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.error || 'Failed to save draft');
+    }
+
+    // Invalidate drafts query so the drafts page updates
+    await queryClient.invalidateQueries({ queryKey: ['task-drafts'] });
+
+    toast({
+      title: draftId ? 'Draft updated' : 'Saved as draft',
+      description: draftId
+        ? 'Your draft has been updated.'
+        : 'Task saved to Drafts. You can convert it to a task later.',
+    });
+
+    if (createMultiple) {
+      setName('');
+      setDescription(null);
+      setTimeout(() => {
+        const input = document.querySelector<HTMLInputElement>(
+          'input[data-task-name-input]'
+        );
+        input?.focus();
+      }, 0);
+    } else {
+      setName('');
+      setDescription(null);
+      setPriority(null);
+      setStartDate(undefined);
+      setEndDate(undefined);
+      setEstimationPoints(null);
+      setSelectedLabels([]);
+      setSelectedAssignees([]);
+      setSelectedProjects([]);
+      onClose();
+    }
+  } catch (error: unknown) {
+    console.error('Error saving draft:', error);
+    toast({
+      title: 'Error saving draft',
+      description: (error as Error).message || 'Please try again later',
+      variant: 'destructive',
+    });
+  } finally {
+    setIsLoading(false);
+    setIsSaving(false);
+  }
+}
+
+// Helper function for creating tasks
+async function handleCreateTask({
+  wsId,
+  name,
+  descriptionString,
+  descriptionYjsState,
+  priority,
+  startDate,
+  endDate,
+  selectedListId,
+  estimationPoints,
+  selectedLabels,
+  selectedAssignees,
+  selectedProjects,
+  totalDuration,
+  isSplittable,
+  minSplitDurationMinutes,
+  maxSplitDurationMinutes,
+  calendarHours,
+  autoSchedule,
+  parentTaskId,
+  pendingRelationship,
+  pendingTaskRelationships,
+  isPersonalWorkspace,
+  user,
+  userTaskSettings,
+  createMultiple,
+  boardId,
+  broadcast,
+  queryClient,
+  toast,
+  onUpdate,
+  onClose,
+  setIsLoading,
+  setIsSaving,
+  setName,
+  setDescription,
+  setPriority,
+  setStartDate,
+  setEndDate,
+  setEstimationPoints,
+  setSelectedLabels,
+  setSelectedAssignees,
+  setSelectedProjects,
+}: {
+  wsId: string;
+  name: string;
+  descriptionString: string | null;
+  descriptionYjsState: number[] | null;
+  priority: 'critical' | 'high' | 'low' | 'normal' | null;
+  startDate: Date | undefined;
+  endDate: Date | undefined;
+  selectedListId: string;
+  estimationPoints: number | null | undefined;
+  selectedLabels: Array<{
+    id: string;
+    name?: string;
+    color?: string;
+    created_at?: string;
+  }>;
+  selectedAssignees: Array<{
+    id: string;
+    user_id?: string | null;
+    display_name?: string | null;
+    avatar_url?: string | null;
+  }>;
+  selectedProjects: Array<{ id: string; name?: string; status?: string }>;
+  totalDuration: number | null;
+  isSplittable: boolean;
+  minSplitDurationMinutes: number | null;
+  maxSplitDurationMinutes: number | null;
+  calendarHours: CalendarHoursType | null;
+  autoSchedule: boolean;
+  parentTaskId?: string;
+  pendingRelationship?: PendingRelationship;
+  pendingTaskRelationships?: PendingTaskRelationships;
+  isPersonalWorkspace: boolean;
+  user: {
+    id: string;
+    display_name?: string | null;
+    avatar_url?: string | null;
+  } | null;
+  userTaskSettings?: { task_auto_assign_to_self: boolean };
+  createMultiple: boolean;
+  boardId: string;
+  broadcast: BoardBroadcastFn | null;
+  queryClient: QueryClient;
+  toast: ReturnType<typeof useToast>['toast'];
+  onUpdate: () => void;
+  onClose: () => void;
+  setIsLoading: (loading: boolean) => void;
+  setIsSaving: (saving: boolean) => void;
+  setName: React.Dispatch<React.SetStateAction<string>>;
+  setDescription: React.Dispatch<React.SetStateAction<JSONContent | null>>;
+  setPriority: React.Dispatch<
+    React.SetStateAction<'critical' | 'high' | 'low' | 'normal' | null>
+  >;
+  setStartDate: React.Dispatch<React.SetStateAction<Date | undefined>>;
+  setEndDate: React.Dispatch<React.SetStateAction<Date | undefined>>;
+  setEstimationPoints: React.Dispatch<
+    React.SetStateAction<number | null | undefined>
+  >;
+  setSelectedLabels: React.Dispatch<
+    React.SetStateAction<
+      Array<{ id: string; name: string; color: string; created_at: string }>
+    >
+  >;
+  setSelectedAssignees: React.Dispatch<
+    React.SetStateAction<
+      Array<{
+        id: string;
+        user_id?: string | null;
+        display_name?: string | null;
+        avatar_url?: string | null;
+      }>
+    >
+  >;
+  setSelectedProjects: React.Dispatch<
+    React.SetStateAction<Array<{ id: string; name: string }>>
+  >;
+}) {
+  try {
+    let resolvedUserId = user?.id;
+    if (!resolvedUserId) {
+      const {
+        data: { user: authUser },
+      } = await supabase.auth.getUser();
+      resolvedUserId = authUser?.id;
+    }
+
+    let desiredAssignees = [...selectedAssignees];
+    if (
+      desiredAssignees.length === 0 &&
+      userTaskSettings?.task_auto_assign_to_self &&
+      resolvedUserId &&
+      !isPersonalWorkspace
+    ) {
+      desiredAssignees = [
+        {
+          id: resolvedUserId,
+          user_id: resolvedUserId,
+        },
+      ];
+    }
+
+    const taskData: Partial<Task> = {
+      name: name.trim(),
+      description: descriptionString || '',
+      priority: priority,
+      start_date: startDate ? startDate.toISOString() : undefined,
+      end_date: endDate ? endDate.toISOString() : undefined,
+      estimation_points: estimationPoints ?? null,
+      // IMPORTANT: scheduling settings are personal and stored separately
+      // (task_user_scheduling_settings). Do not persist them to the shared task row.
+    };
+    const newTask = await createTask(wsId, selectedListId, {
+      ...taskData,
+      description_yjs_state: descriptionYjsState ?? undefined,
+      label_ids: selectedLabels.map((label) => label.id),
+      assignee_ids: desiredAssignees
+        .map((assignee) => assignee.user_id || assignee.id)
+        .filter((assigneeId): assigneeId is string => !!assigneeId),
+      project_ids: selectedProjects.map((project) => project.id),
+    });
+
+    // Save per-user scheduling settings for the creator (if any were provided)
+    const hasAnySchedulingValue =
+      totalDuration != null ||
+      calendarHours != null ||
+      autoSchedule === true ||
+      isSplittable === true ||
+      minSplitDurationMinutes != null ||
+      maxSplitDurationMinutes != null;
+
+    if (hasAnySchedulingValue) {
+      try {
+        await updateTaskSchedulingSettings(wsId, newTask.id, {
+          total_duration: totalDuration,
+          is_splittable: isSplittable,
+          min_split_duration_minutes: minSplitDurationMinutes,
+          max_split_duration_minutes: maxSplitDurationMinutes,
+          calendar_hours: calendarHours ?? null,
+          auto_schedule: autoSchedule,
+        });
+      } catch (schedulingError) {
+        console.error(
+          'Failed to save personal scheduling settings via API:',
+          schedulingError
+        );
+      }
+    }
+
+    const normalizedPendingRelationships =
+      pendingTaskRelationships ??
+      getLegacyPendingTaskRelationships(parentTaskId, pendingRelationship);
+
+    const affectedRelationshipTaskIds = await persistPendingTaskRelationships(
+      wsId,
+      newTask.id,
+      normalizedPendingRelationships,
+      queryClient
+    );
+
+    const nextLabels: Task['labels'] = selectedLabels.flatMap((label) =>
+      label.name && label.color && label.created_at
+        ? [
+            {
+              id: label.id,
+              name: label.name,
+              color: label.color,
+              created_at: label.created_at,
+            },
+          ]
+        : []
+    );
+
+    const finalAssignees = desiredAssignees;
+
+    const nextProjects: Task['projects'] = selectedProjects.flatMap(
+      (project) =>
+        project.name && project.status
+          ? [
+              {
+                id: project.id,
+                name: project.name,
+                status: project.status,
+              },
+            ]
+          : []
+    );
+
+    const createdTaskWithRelations: Task = {
+      ...(newTask as Task),
+      labels: nextLabels,
+      assignees: finalAssignees.map((assignee) => ({
+        id: assignee.user_id || assignee.id,
+        display_name: assignee.display_name ?? undefined,
+        avatar_url: assignee.avatar_url ?? undefined,
+      })),
+      projects: nextProjects,
+      relationship_summary: {
+        parent_task_id: normalizedPendingRelationships.parentTask?.id ?? null,
+        parent_task: normalizedPendingRelationships.parentTask
+          ? {
+              id: normalizedPendingRelationships.parentTask.id,
+              name: normalizedPendingRelationships.parentTask.name,
+              display_number:
+                normalizedPendingRelationships.parentTask.display_number ??
+                null,
+              ticket_prefix:
+                normalizedPendingRelationships.parentTask.ticket_prefix ?? null,
+            }
+          : null,
+        child_count: normalizedPendingRelationships.childTasks.length,
+        completed_child_count: normalizedPendingRelationships.childTasks.filter(
+          (childTask) => childTask.completed
+        ).length,
+        blocked_by_count: normalizedPendingRelationships.blockedByTasks.length,
+        blocking_count: normalizedPendingRelationships.blockingTasks.length,
+        related_count: normalizedPendingRelationships.relatedTasks.length,
+      },
+    };
+
+    const locallyCreatedTask = {
+      ...(createdTaskWithRelations as Task & { _localMutationAt?: number }),
+      _localMutationAt: Date.now(),
+    } as Task;
+
+    // Update cache
+    queryClient.setQueryData(['tasks', boardId], (old: Task[] | undefined) => {
+      if (!old) return [locallyCreatedTask];
+      if (old.some((t) => t.id === newTask.id)) return old;
+      return [...old, locallyCreatedTask];
+    });
+    applyPendingRelationshipSummary({
+      boardId,
+      newTaskId: newTask.id,
+      queryClient,
+      pendingTaskRelationships: normalizedPendingRelationships,
+    });
+    await queryClient.invalidateQueries({ queryKey: ['time-tracking-data'] });
+
+    // Broadcast the new task to other clients
+    broadcast?.('task:upsert', { task: createdTaskWithRelations });
+    const hasRelations =
+      nextLabels.length > 0 ||
+      finalAssignees.length > 0 ||
+      nextProjects.length > 0;
+    if (hasRelations) {
+      broadcast?.('task:relations-changed', { taskId: newTask.id });
+    }
+    if (affectedRelationshipTaskIds.length > 0) {
+      broadcast?.('task:deps-changed', {
+        taskIds: affectedRelationshipTaskIds,
+      });
+    }
+
+    toast({
+      title: normalizedPendingRelationships.parentTask
+        ? 'Sub-task created'
+        : 'Task created',
+      description: normalizedPendingRelationships.parentTask
+        ? 'New sub-task added.'
+        : 'New task added.',
+    });
+    onUpdate();
+
+    if (createMultiple) {
+      setName('');
+      setDescription(null);
+      setTimeout(() => {
+        const input = document.querySelector<HTMLInputElement>(
+          'input[data-task-name-input]'
+        );
+        input?.focus();
+      }, 0);
+    } else {
+      setName('');
+      setDescription(null);
+      setPriority(null);
+      setStartDate(undefined);
+      setEndDate(undefined);
+      setEstimationPoints(null);
+      setSelectedLabels([]);
+      setSelectedAssignees([]);
+      setSelectedProjects([]);
+      onClose();
+    }
+  } catch (error: unknown) {
+    console.error('Error creating task:', error);
+    toast({
+      title: 'Error creating task',
+      description: (error as Error).message || 'Please try again later',
+      variant: 'destructive',
+    });
+  } finally {
+    setIsLoading(false);
+    setIsSaving(false);
+  }
+}
+
+export function getLegacyPendingTaskRelationships(
+  parentTaskId?: string,
+  pendingRelationship?: PendingRelationship
+): PendingTaskRelationships {
+  if (parentTaskId) {
+    return {
+      parentTask: {
+        id: parentTaskId,
+        name: pendingRelationship?.relatedTaskName || parentTaskId,
+      },
+      childTasks: [],
+      blockingTasks: [],
+      blockedByTasks: [],
+      relatedTasks: [],
+    };
+  }
+
+  if (!pendingRelationship?.relatedTaskId) {
+    return {
+      parentTask: null,
+      childTasks: [],
+      blockingTasks: [],
+      blockedByTasks: [],
+      relatedTasks: [],
+    };
+  }
+
+  const relatedTask: RelatedTaskInfo = {
+    id: pendingRelationship.relatedTaskId,
+    name:
+      pendingRelationship.relatedTaskName || pendingRelationship.relatedTaskId,
+  };
+
+  switch (pendingRelationship.type) {
+    case 'subtask':
+      return {
+        parentTask: relatedTask,
+        childTasks: [],
+        blockingTasks: [],
+        blockedByTasks: [],
+        relatedTasks: [],
+      };
+    case 'parent':
+      return {
+        parentTask: null,
+        childTasks: [relatedTask],
+        blockingTasks: [],
+        blockedByTasks: [],
+        relatedTasks: [],
+      };
+    case 'blocking':
+      return {
+        parentTask: null,
+        childTasks: [],
+        blockingTasks: [],
+        blockedByTasks: [relatedTask],
+        relatedTasks: [],
+      };
+    case 'blocked-by':
+      return {
+        parentTask: null,
+        childTasks: [],
+        blockingTasks: [relatedTask],
+        blockedByTasks: [],
+        relatedTasks: [],
+      };
+    case 'related':
+      return {
+        parentTask: null,
+        childTasks: [],
+        blockingTasks: [],
+        blockedByTasks: [],
+        relatedTasks: [relatedTask],
+      };
+  }
+}
+
+export async function persistPendingTaskRelationships(
+  wsId: string,
+  newTaskId: string,
+  pendingTaskRelationships: PendingTaskRelationships,
+  queryClient: QueryClient
+) {
+  const affectedTaskIds = new Set<string>([newTaskId]);
+
+  const createRelationship = async ({
+    sourceTaskId,
+    targetTaskId,
+    type,
+  }: {
+    sourceTaskId: string;
+    targetTaskId: string;
+    type: 'parent_child' | 'blocks' | 'related';
+  }) => {
+    await createWorkspaceTaskRelationship(
+      wsId,
+      sourceTaskId,
+      {
+        source_task_id: sourceTaskId,
+        target_task_id: targetTaskId,
+        type,
+      },
+      internalApiBaseUrl ? { baseUrl: internalApiBaseUrl } : undefined
+    );
+    affectedTaskIds.add(sourceTaskId);
+    affectedTaskIds.add(targetTaskId);
+  };
+
+  try {
+    if (pendingTaskRelationships.parentTask?.id) {
+      await createRelationship({
+        sourceTaskId: pendingTaskRelationships.parentTask.id,
+        targetTaskId: newTaskId,
+        type: 'parent_child',
+      });
+    }
+
+    for (const childTask of dedupeById(pendingTaskRelationships.childTasks)) {
+      await createRelationship({
+        sourceTaskId: newTaskId,
+        targetTaskId: childTask.id,
+        type: 'parent_child',
+      });
+    }
+
+    for (const blockingTask of dedupeById(
+      pendingTaskRelationships.blockingTasks
+    )) {
+      await createRelationship({
+        sourceTaskId: newTaskId,
+        targetTaskId: blockingTask.id,
+        type: 'blocks',
+      });
+    }
+
+    for (const blockedByTask of dedupeById(
+      pendingTaskRelationships.blockedByTasks
+    )) {
+      await createRelationship({
+        sourceTaskId: blockedByTask.id,
+        targetTaskId: newTaskId,
+        type: 'blocks',
+      });
+    }
+
+    for (const relatedTask of dedupeById(
+      pendingTaskRelationships.relatedTasks
+    )) {
+      await createRelationship({
+        sourceTaskId: relatedTask.id,
+        targetTaskId: newTaskId,
+        type: 'related',
+      });
+    }
+  } catch (relationshipError) {
+    console.error(
+      'Failed to create pending task relationships:',
+      relationshipError
+    );
+  }
+
+  await Promise.all(
+    Array.from(affectedTaskIds).map((taskId) =>
+      queryClient.invalidateQueries({
+        queryKey: ['task-relationships', taskId],
+      })
+    )
+  );
+
+  return Array.from(affectedTaskIds);
+}
+
+// Helper function for updating tasks
+async function handleUpdateTask({
+  taskId,
+  wsId,
+  boardId,
+  name,
+  descriptionString,
+  descriptionYjsState,
+  priority,
+  startDate,
+  endDate,
+  selectedListId,
+  estimationPoints,
+  collaborationMode,
+  flushEditorPendingRef,
+  updateSharedTaskMutation,
+  shareCode,
+  queryClient,
+  toast,
+  onUpdate,
+  onClose,
+  setIsLoading,
+  setIsSaving,
+}: {
+  taskId?: string;
+  wsId: string;
+  boardId: string;
+  name: string;
+  descriptionString: string | null;
+  descriptionYjsState: number[] | null;
+  priority: 'critical' | 'high' | 'low' | 'normal' | null;
+  startDate: Date | undefined;
+  endDate: Date | undefined;
+  selectedListId: string;
+  estimationPoints: number | null | undefined;
+  collaborationMode: boolean;
+  flushEditorPendingRef: React.MutableRefObject<
+    (() => JSONContent | null) | undefined
+  >;
+  updateSharedTaskMutation: ReturnType<typeof useUpdateSharedTask>;
+  shareCode?: string;
+  queryClient: QueryClient;
+  toast: ReturnType<typeof useToast>['toast'];
+  onUpdate: () => void;
+  onClose: () => void;
+  setIsLoading: (loading: boolean) => void;
+  setIsSaving: (saving: boolean) => void;
+}) {
+  const taskUpdates: WorkspaceTaskUpdatePayload = {
+    name: name.trim(),
+    priority: priority,
+    start_date: startDate ? startDate.toISOString() : undefined,
+    end_date: endDate ? endDate.toISOString() : undefined,
+    list_id: selectedListId,
+    estimation_points: estimationPoints ?? null,
+    // IMPORTANT: scheduling settings are personal and stored separately
+    // (task_user_scheduling_settings). Do not persist them to the shared task row.
+  };
+
+  if (taskId) {
+    // Shared task editing (no workspace membership required): use shared endpoint.
+    if (shareCode) {
+      const sharedDescription =
+        collaborationMode && flushEditorPendingRef.current
+          ? (serializeTaskDescriptionContent(flushEditorPendingRef.current()) ??
+            undefined)
+          : (descriptionString ?? undefined);
+
+      updateSharedTaskMutation.mutate(
+        {
+          shareCode,
+          updates: {
+            ...taskUpdates,
+            description: sharedDescription,
+          },
+        },
+        {
+          onSuccess: async () => {
+            toast({
+              title: 'Task updated',
+              description: 'The task has been successfully updated.',
+            });
+            onUpdate();
+            onClose();
+          },
+          onError: (error: Error) => {
+            console.error('Error updating shared task:', error);
+            toast({
+              title: 'Error updating task',
+              description: error.message || 'Please try again later',
+              variant: 'destructive',
+            });
+          },
+          onSettled: () => {
+            setIsLoading(false);
+            setIsSaving(false);
+            queryClient.invalidateQueries({ queryKey: ['task-history'] });
+          },
+        }
+      );
+      return;
+    }
+
+    try {
+      await updateWorkspaceTask(wsId, taskId, taskUpdates);
+      await updateWorkspaceTaskDescription(wsId, taskId, {
+        description: descriptionString,
+        description_yjs_state: descriptionYjsState,
+      });
+      updateTaskDescriptionCaches({
+        taskId,
+        descriptionString,
+        boardId,
+        queryClient,
+      });
+      toast({
+        title: 'Task updated',
+        description: 'The task has been successfully updated.',
+      });
+      onUpdate();
+      onClose();
+    } catch (error) {
+      console.error('Error updating task:', error);
+      toast({
+        title: 'Error updating task',
+        description:
+          error instanceof Error ? error.message : 'Please try again later',
+        variant: 'destructive',
+      });
+    } finally {
+      setIsLoading(false);
+      setIsSaving(false);
+      queryClient.invalidateQueries({ queryKey: ['task-history'] });
+    }
+  }
+}