@taskforcehq/taskforce 0.3.328 → 0.3.330

package/dist/hooks/useTaskData.js

@@ -23,9 +23,10 @@
  *   - getTaskRevisionKey(task) — stable revision string for change detection
  */
 import { useState, useEffect, useCallback, useRef } from 'react';
-import { getTaskContentRevision, mergeNormalizedTaskIntoCollections, normalizeTaskFromApi, reconcileTaskCollection } from '../utils/taskNormalization.js';
+import { getTaskContentRevision, mergeNormalizedTaskIntoCollections, normalizeTaskFromApi, reconcileTaskCollection, toTaskCollectionSummary } from '../utils/taskNormalization.js';
 import { resolveTaskReferenceId } from '../utils/taskReferences.js';
-export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks, setLoadingTasks, getCurrentWorkspaceId, workspaceResetKey, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, handleUnauthorized, authRequiredForApi }) {
+import { canonicalWorkspaceSyncJson } from '../sync/v3/canonicalWorkspaceSyncJson.js';
+export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks, setLoadingTasks, getCurrentWorkspaceId, workspaceResetKey, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, handleUnauthorized, authRequiredForApi, setError, setLoading, pendingTaskMetadataOverlaysRef, }) {
     // === SECTION: Revision Tracking ===
     const taskRevisionMapRef = useRef(new Map());
     const hasFetchedTasksRef = useRef(false);
@@ -34,6 +35,21 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
     const archivedTasksRef = useRef(archivedTasks);
     const tasksAbortRef = useRef(null);
     const archiveAbortRef = useRef(null);
+    const taskDetailAbortRef = useRef(null);
+    const taskDetailCacheRef = useRef(new Map());
+    const [taskDetails, setTaskDetails] = useState([]);
+    const [staleTaskDetailRevisions, setStaleTaskDetailRevisions] = useState({});
+    const getTaskSummaryRevision = useCallback((task) => (String(task.detailRevision || JSON.stringify([
+        task.updatedAt || task.createdAt || '',
+        task.commentCount || 0,
+        task.checklistCount || 0,
+        task.completedChecklistCount || 0,
+        task.attachmentCount || 0,
+        task.relationshipCount || 0,
+    ]))), []);
+    const publishTaskDetailCache = useCallback(() => {
+        setTaskDetails(Array.from(taskDetailCacheRef.current.values(), (entry) => entry.detail));
+    }, []);
     useEffect(() => {
         tasksRef.current = tasks;
     }, [tasks]);
@@ -43,6 +59,26 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
     const getTaskRevisionKey = useCallback((task) => {
         return getTaskContentRevision(task);
     }, []);
+    const preservePendingTaskMetadata = useCallback((task) => {
+        const pending = pendingTaskMetadataOverlaysRef?.current.get(task.id);
+        if (!pending)
+            return task;
+        const patchMatches = Object.entries(pending.patch).every(([key, value]) => {
+            const candidate = task[key];
+            return candidate === undefined || value === undefined
+                ? candidate === value
+                : canonicalWorkspaceSyncJson(candidate) === canonicalWorkspaceSyncJson(value);
+        });
+        const candidateUpdatedAt = Date.parse(String(task.updatedAt || ''));
+        const observedUpdatedAt = Date.parse(String(pending.observedUpdatedAt || ''));
+        if (patchMatches || (Number.isFinite(candidateUpdatedAt)
+            && Number.isFinite(observedUpdatedAt)
+            && candidateUpdatedAt > observedUpdatedAt)) {
+            pendingTaskMetadataOverlaysRef?.current.delete(task.id);
+            return task;
+        }
+        return { ...task, ...pending.patch };
+    }, [pendingTaskMetadataOverlaysRef]);
     const isExpectedAbortFailure = useCallback((error, signal) => {
         if (!signal.aborted)
             return false;
@@ -87,12 +123,68 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
         tasksAbortRef.current = null;
         archiveAbortRef.current?.abort('workspace-reset');
         archiveAbortRef.current = null;
+        const hadPendingTaskDetail = taskDetailAbortRef.current !== null;
+        taskDetailAbortRef.current?.abort('workspace-reset');
+        taskDetailAbortRef.current = null;
+        if (hadPendingTaskDetail)
+            setLoading?.(false);
+        taskDetailCacheRef.current = new Map();
+        setTaskDetails([]);
+        setStaleTaskDetailRevisions({});
         if (typeof window !== 'undefined') {
             highlightTimersRef.current.forEach((timerId) => window.clearTimeout(timerId));
             highlightTimersRef.current.clear();
         }
         setRecentlyChangedTaskIds([]);
-    }, [workspaceResetKey]);
+    }, [setLoading, workspaceResetKey]);
+    useEffect(() => () => {
+        taskDetailAbortRef.current?.abort('unmount');
+    }, []);
+    const reconcileTaskDetailCache = useCallback((summaries, archived) => {
+        const summaryById = new Map(summaries.map((task) => [task.id, task]));
+        let changed = false;
+        const next = new Map(taskDetailCacheRef.current);
+        const nextStaleRevisions = {};
+        const reconciledTaskIds = new Set();
+        for (const [taskId, cached] of next) {
+            const summary = summaryById.get(taskId);
+            const belongsToCollection = Boolean(cached.detail.isArchived) === archived;
+            if (belongsToCollection)
+                reconciledTaskIds.add(taskId);
+            if (!summary && belongsToCollection) {
+                next.delete(taskId);
+                changed = true;
+                continue;
+            }
+            if (summary) {
+                const summaryRevision = getTaskSummaryRevision(summary);
+                if (summaryRevision !== cached.summaryRevision) {
+                    nextStaleRevisions[taskId] = summaryRevision;
+                }
+            }
+        }
+        setStaleTaskDetailRevisions((current) => {
+            const retained = Object.fromEntries(Object.entries(current).filter(([taskId]) => (!reconciledTaskIds.has(taskId))));
+            const combined = { ...retained, ...nextStaleRevisions };
+            const currentEntries = Object.entries(current);
+            const combinedEntries = Object.entries(combined);
+            return currentEntries.length === combinedEntries.length
+                && currentEntries.every(([taskId, revision]) => combined[taskId] === revision)
+                ? current
+                : combined;
+        });
+        if (changed) {
+            taskDetailCacheRef.current = next;
+            publishTaskDetailCache();
+        }
+    }, [getTaskSummaryRevision, publishTaskDetailCache]);
+    const cancelTaskDetailLoad = useCallback(() => {
+        const hadPendingTaskDetail = taskDetailAbortRef.current !== null;
+        taskDetailAbortRef.current?.abort('navigation');
+        taskDetailAbortRef.current = null;
+        if (hadPendingTaskDetail)
+            setLoading?.(false);
+    }, [setLoading]);
     // === SECTION: Fetch Functions ===
     const fetchTasks = useCallback(async (isSilent = false, options) => {
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
@@ -121,11 +213,12 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
             }
             if (res.ok) {
                 const data = await res.json();
-                const sanitized = (data.tasks || []).map((t) => normalizeTaskFromApi(t));
+                const sanitized = (data.tasks || []).map((t) => (preservePendingTaskMetadata(normalizeTaskFromApi(t))));
                 const liveWorkspaceId = String(getCurrentWorkspaceId() || '').trim();
                 if (liveWorkspaceId !== requestWorkspaceId) {
                     return;
                 }
+                reconcileTaskDetailCache(sanitized, false);
                 const nextRevisionMap = new Map();
                 const changedTaskIds = [];
                 const highlightChangedTaskIds = options?.highlightChangedTaskIds === undefined
@@ -178,7 +271,9 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
         setLoadingTasks,
         authRequiredForApi,
         shouldDeferProtectedApiCalls,
-        shouldBlockProtectedApiCalls
+        shouldBlockProtectedApiCalls,
+        reconcileTaskDetailCache,
+        preservePendingTaskMetadata,
     ]);
     const fetchArchive = useCallback(async (isSilent = false, options) => {
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
@@ -199,9 +294,10 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
                     return false;
                 }
                 const sanitized = (data.archived || []).map((t) => ({
-                    ...normalizeTaskFromApi(t),
+                    ...preservePendingTaskMetadata(normalizeTaskFromApi(t)),
                     isArchived: true
                 }));
+                reconcileTaskDetailCache(sanitized, true);
                 const previousArchivedTasks = archivedTasksRef.current;
                 const reconciledArchivedTasks = reconcileTaskCollection(previousArchivedTasks, sanitized);
                 archivedTasksRef.current = reconciledArchivedTasks;
@@ -225,7 +321,109 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
                     setLoadingTasks(false);
             }
         }
-    }, [getCurrentWorkspaceId, isExpectedAbortFailure, setArchivedTasks, setLoadingTasks, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls]);
+    }, [getCurrentWorkspaceId, isExpectedAbortFailure, preservePendingTaskMetadata, reconcileTaskDetailCache, setArchivedTasks, setLoadingTasks, shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls]);
+    const loadTaskDetail = useCallback(async (task, options) => {
+        const force = options?.force === true;
+        if (!force && !task.isSummary) {
+            const summary = toTaskCollectionSummary(task);
+            taskDetailCacheRef.current.set(task.id, { detail: task, summaryRevision: getTaskSummaryRevision(summary) });
+            setStaleTaskDetailRevisions((current) => {
+                if (!Object.prototype.hasOwnProperty.call(current, task.id))
+                    return current;
+                const next = { ...current };
+                delete next[task.id];
+                return next;
+            });
+            publishTaskDetailCache();
+            return task;
+        }
+        const cached = taskDetailCacheRef.current.get(task.id);
+        let requestedSummary = task;
+        let summaryRevision = getTaskSummaryRevision(requestedSummary);
+        if (!force && cached && cached.summaryRevision === summaryRevision)
+            return cached.detail;
+        const requestWorkspaceId = String(getCurrentWorkspaceId() || '').trim();
+        taskDetailAbortRef.current?.abort('superseded');
+        const abortController = new AbortController();
+        taskDetailAbortRef.current = abortController;
+        setLoading?.(true);
+        setError?.('');
+        try {
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                const response = await fetch(`/api/taskforce/task/${encodeURIComponent(requestedSummary.id)}`, {
+                    signal: abortController.signal,
+                });
+                if (response.status === 401) {
+                    handleUnauthorized();
+                    return null;
+                }
+                if (response.status === 404) {
+                    setError?.('Task not found. It may have moved or been deleted.');
+                    return null;
+                }
+                if (!response.ok) {
+                    setError?.('Unable to load task details.');
+                    return null;
+                }
+                const normalizedDetail = normalizeTaskFromApi(await response.json());
+                const liveWorkspaceId = String(getCurrentWorkspaceId() || '').trim();
+                if (abortController.signal.aborted || liveWorkspaceId !== requestWorkspaceId)
+                    return null;
+                const currentSummary = [...tasksRef.current, ...archivedTasksRef.current]
+                    .find((candidate) => candidate.id === requestedSummary.id);
+                if (!currentSummary) {
+                    setError?.('Task not found. It may have moved or been deleted.');
+                    return null;
+                }
+                const currentRevision = getTaskSummaryRevision(currentSummary);
+                if (currentRevision !== summaryRevision) {
+                    if (attempt === 0 && currentSummary) {
+                        requestedSummary = currentSummary;
+                        summaryRevision = currentRevision;
+                        continue;
+                    }
+                    setError?.('Task details changed while loading. Please open the task again.');
+                    return null;
+                }
+                if (requestedSummary.updatedAt
+                    && normalizedDetail.updatedAt
+                    && Date.parse(normalizedDetail.updatedAt) < Date.parse(requestedSummary.updatedAt)) {
+                    setError?.('Task details changed while loading. Please open the task again.');
+                    return null;
+                }
+                const detail = {
+                    ...normalizedDetail,
+                    detailRevision: normalizedDetail.detailRevision || summaryRevision,
+                };
+                if (options?.shouldCommit && !options.shouldCommit())
+                    return null;
+                taskDetailCacheRef.current.set(detail.id, { detail, summaryRevision });
+                setStaleTaskDetailRevisions((current) => {
+                    if (!Object.prototype.hasOwnProperty.call(current, detail.id))
+                        return current;
+                    const next = { ...current };
+                    delete next[detail.id];
+                    return next;
+                });
+                publishTaskDetailCache();
+                return detail;
+            }
+            return null;
+        }
+        catch (error) {
+            if (isExpectedAbortFailure(error, abortController.signal))
+                return null;
+            console.error('[Taskforce] Failed to fetch task detail:', error);
+            setError?.('Unable to load task details.');
+            return null;
+        }
+        finally {
+            if (taskDetailAbortRef.current === abortController) {
+                taskDetailAbortRef.current = null;
+                setLoading?.(false);
+            }
+        }
+    }, [getCurrentWorkspaceId, getTaskSummaryRevision, handleUnauthorized, isExpectedAbortFailure, publishTaskDetailCache, setError, setLoading]);
     const refreshTaskCollections = useCallback(async (options) => {
         const isSilent = options?.isSilent !== false;
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
@@ -253,7 +451,36 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
     }, [refreshTaskCollections]);
     // === SECTION: Merge Helper ===
     const mergeTaskFromServer = useCallback((task) => {
-        const merged = mergeNormalizedTaskIntoCollections(task, tasksRef.current, archivedTasksRef.current);
+        const normalized = preservePendingTaskMetadata(normalizeTaskFromApi(task));
+        const existingSummary = [...tasksRef.current, ...archivedTasksRef.current]
+            .find((candidate) => candidate.id === normalized.id);
+        const collectionSummary = normalized.isSummary
+            ? normalized
+            : toTaskCollectionSummary({
+                ...normalized,
+                detailRevision: undefined,
+                commentCount: normalized.commentCount ?? (normalized.comments ? undefined : existingSummary?.commentCount),
+                checklistCount: normalized.checklistCount ?? (normalized.checklistItems ? undefined : existingSummary?.checklistCount),
+                completedChecklistCount: normalized.completedChecklistCount
+                    ?? (normalized.checklistItems ? undefined : existingSummary?.completedChecklistCount),
+                attachmentCount: normalized.attachmentCount ?? (normalized.attachments ? undefined : existingSummary?.attachmentCount),
+                relationshipCount: normalized.relationshipCount ?? existingSummary?.relationshipCount ?? 0,
+            });
+        if (!normalized.isSummary) {
+            taskDetailCacheRef.current.set(normalized.id, {
+                detail: normalized,
+                summaryRevision: getTaskSummaryRevision(collectionSummary),
+            });
+            publishTaskDetailCache();
+            setStaleTaskDetailRevisions((current) => {
+                if (!Object.prototype.hasOwnProperty.call(current, normalized.id))
+                    return current;
+                const next = { ...current };
+                delete next[normalized.id];
+                return next;
+            });
+        }
+        const merged = mergeNormalizedTaskIntoCollections(collectionSummary, tasksRef.current, archivedTasksRef.current);
         const tasksChanged = merged.tasks !== tasksRef.current;
         const archivedTasksChanged = merged.archivedTasks !== archivedTasksRef.current;
         tasksRef.current = merged.tasks;
@@ -262,17 +489,21 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
             setTasks(merged.tasks);
         if (archivedTasksChanged)
             setArchivedTasks(merged.archivedTasks);
-    }, [setTasks, setArchivedTasks]);
+    }, [getTaskSummaryRevision, preservePendingTaskMetadata, publishTaskDetailCache, setTasks, setArchivedTasks]);
     return {
         // Stable refs (for use inside closures)
         tasksRef,
         archivedTasksRef,
+        taskDetails,
+        staleTaskDetailRevisions,
         // Recently changed
         recentlyChangedTaskIds,
         markRecentlyChangedTasks,
         // Fetch functions
         fetchTasks,
         fetchArchive,
+        loadTaskDetail,
+        cancelTaskDetailLoad,
         refreshTaskCollections,
         refreshTaskCollectionsFromInvalidation,
         // Helpers

package/dist/hooks/useTaskMutations.d.ts

@@ -8,11 +8,13 @@ import type { DurableTaskDeleteMutationAdapter } from './sync/useDurableTaskDele
 import type { DurableTaskRestoreMutationAdapter } from './sync/useDurableTaskRestoreMutation.js';
 import type { TaskRestoreDestination } from '../shared/taskRestoreDestination.js';
 import type { DurableTaskTargetStatus } from '../core/TaskDurableStatusMutationService.js';
+import type { PendingTaskMetadataOverlay } from './useTaskData.js';
 import { createCloudTaskHttpMutationClient } from './tasks/taskHttpMutation.js';
 export interface UseTaskMutationsProps {
     tasks: TaskItem[];
     archivedTasks: TaskItem[];
     editingTaskId: string | null;
+    editingTaskDetailRevision?: string | null;
     setTasks: React.Dispatch<React.SetStateAction<TaskItem[]>>;
     setArchivedTasks: React.Dispatch<React.SetStateAction<TaskItem[]>>;
     setDeletedTasks: React.Dispatch<React.SetStateAction<DeletedTaskRecord[]>>;
@@ -44,6 +46,14 @@ export interface UseTaskMutationsProps {
     durableTaskHttpRootActivationEnabled?: boolean;
     workspaceId?: string;
     taskHttpMutationClient?: ReturnType<typeof createCloudTaskHttpMutationClient>;
+    onTaskRevisionConflict?: (taskId: string, currentDetailRevision: string | null) => TaskRevisionConflictResolution | void | Promise<TaskRevisionConflictResolution | void>;
+    onTaskMutationAccepted?: (task: TaskItem) => void;
+    pendingTaskMetadataOverlaysRef?: MutableRefObject<Map<string, PendingTaskMetadataOverlay>>;
+}
+export interface TaskRevisionConflictResolution {
+    handled: boolean;
+    retryDetailRevision?: string;
+    retryPatch?: Partial<TaskItem>;
 }
 export interface DeletedTaskRestoreFailure {
     deletedRecordId: string;
@@ -58,13 +68,13 @@ export interface DeletedTaskRestoreBatchResult {
     succeeded: DeletedTaskRecord[];
     failed: DeletedTaskRestoreFailure[];
 }
-export declare function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, mutateTaskMetadata, mutateTaskStatus, mutateTaskLifecycle, mutateTaskDelete, mutateTaskRestore, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, durableTaskDeleteActivationEnabled, durableTaskHttpRootActivationEnabled, workspaceId, taskHttpMutationClient, }: UseTaskMutationsProps): {
+export declare function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingTaskDetailRevision, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, mutateTaskMetadata, mutateTaskStatus, mutateTaskLifecycle, mutateTaskDelete, mutateTaskRestore, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, durableTaskDeleteActivationEnabled, durableTaskHttpRootActivationEnabled, workspaceId, taskHttpMutationClient, onTaskRevisionConflict, onTaskMutationAccepted, pendingTaskMetadataOverlaysRef, }: UseTaskMutationsProps): {
     copiedId: string | null;
     handleDelete: (id: string, archive?: boolean, options?: {
         skipConfirm?: boolean;
     }) => Promise<boolean>;
     handleUpdateTask: (id: string, updates: Partial<TaskItem>) => Promise<boolean | undefined>;
-    handleSetStatus: (task: TaskItem, status: DurableTaskTargetStatus, updates?: Partial<TaskItem>) => Promise<void>;
+    handleSetStatus: (task: TaskItem, status: DurableTaskTargetStatus, updates?: Partial<TaskItem>, expectedDetailRevisionOverride?: string | null) => Promise<void>;
     handleToggleComplete: (task: TaskItem) => Promise<void>;
     handleToggleCancel: (task: TaskItem) => Promise<void>;
     handleToggleInProgress: (task: TaskItem) => Promise<void>;