@taskforcehq/taskforce 0.3.327 → 0.3.329

package/dist/hooks/useTaskMutations.js

@@ -36,11 +36,12 @@ function taskHttpObservedPrecondition(task, taskId) {
     return {
         taskId,
         updatedAt: task?.updatedAt ?? null,
+        detailRevision: task?.detailRevision ?? null,
         status: task?.status ?? null,
         isArchived: task?.isArchived === true,
     };
 }
-export 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 = false, durableTaskStatusActivationEnabled = false, durableTaskDeleteActivationEnabled = false, durableTaskHttpRootActivationEnabled = false, workspaceId = 'default', taskHttpMutationClient, }) {
+export function useTaskMutations({ tasks, archivedTasks, editingTaskId, editingTaskDetailRevision = null, 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 = false, durableTaskStatusActivationEnabled = false, durableTaskDeleteActivationEnabled = false, durableTaskHttpRootActivationEnabled = false, workspaceId = 'default', taskHttpMutationClient, onTaskRevisionConflict, onTaskMutationAccepted, }) {
     const authoritativeTaskSnapshotsRef = useRef(new Map());
     useEffect(() => {
         if (typeof window === 'undefined')
@@ -418,8 +419,10 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             pushNotice(message, 'error');
             return true;
         }
-        if ('task' in result && result.task)
+        if ('task' in result && result.task) {
             mergeTaskFromServer(result.task);
+            onTaskMutationAccepted?.(result.task);
+        }
         if (result.state === 'accepted') {
             setError('');
         }
@@ -441,8 +444,10 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             pushNotice(message, 'error');
         }
         return true;
-    }, [mergeTaskFromServer, pushNotice, setArchivedTasks, setError, setTasks]);
-    const handleSetStatus = useCallback(async (task, status, updates = {}) => {
+    }, [mergeTaskFromServer, onTaskMutationAccepted, pushNotice, setArchivedTasks, setError, setTasks]);
+    const handleSetStatus = useCallback(async (task, status, updates = {}, expectedDetailRevisionOverride) => {
+        const expectedDetailRevision = expectedDetailRevisionOverride
+            ?? (task.id === editingTaskId ? editingTaskDetailRevision : null);
         const containsDurableMetadata = Object.keys(updates)
             .some((key) => DURABLE_TASK_METADATA_FIELD_NAMES.has(key));
         const unsupportedFields = Object.keys(updates).filter((key) => (!TASK_STATUS_CONTROL_FIELDS.has(key) && !DURABLE_TASK_METADATA_FIELD_NAMES.has(key)));
@@ -468,17 +473,55 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         setArchivedTasks((current) => current.map((item) => item.id === task.id ? { ...item, ...optimisticPatch } : item));
         if (mutateTaskStatus) {
             try {
-                const assigneeIntent = Object.prototype.hasOwnProperty.call(updates, 'assignee')
-                    ? { kind: 'set', value: updates.assignee ?? null }
-                    : { kind: 'preserve' };
-                const metadataPatch = selectDurableTaskMetadataPatch(updates);
-                delete metadataPatch.assignee;
-                const durableResult = await mutateTaskStatus(task.id, {
-                    status,
-                    assigneeIntent,
-                    canceledReason: status === 'cancelled' ? (updates.canceledReason ?? null) : null,
-                    metadataPatch,
-                });
+                const buildDurablePayload = (targetStatus, targetUpdates, detailRevision) => {
+                    const assigneeIntent = Object.prototype.hasOwnProperty.call(targetUpdates, 'assignee')
+                        ? { kind: 'set', value: targetUpdates.assignee ?? null }
+                        : { kind: 'preserve' };
+                    const metadataPatch = selectDurableTaskMetadataPatch(targetUpdates);
+                    delete metadataPatch.assignee;
+                    return {
+                        status: targetStatus,
+                        assigneeIntent,
+                        canceledReason: targetStatus === 'cancelled'
+                            ? (targetUpdates.canceledReason ?? null)
+                            : null,
+                        metadataPatch,
+                        ...(detailRevision ? { expectedDetailRevision: detailRevision } : {}),
+                    };
+                };
+                let durableResult = await mutateTaskStatus(task.id, buildDurablePayload(status, updates, expectedDetailRevision));
+                if (durableResult
+                    && (durableResult.state === 'rejected' || durableResult.state === 'failed')
+                    && durableResult.errorCode === 'TASK_DETAIL_REVISION_CONFLICT') {
+                    const previousTask = previousTasks.find((item) => item.id === task.id)
+                        || previousArchivedTasks.find((item) => item.id === task.id);
+                    setTasks((current) => rollbackTargetTaskPatch(current, previousTask, task.id, optimisticPatch));
+                    setArchivedTasks((current) => rollbackTargetTaskPatch(current, previousTask, task.id, optimisticPatch));
+                    const resolution = await onTaskRevisionConflict?.(task.id, null);
+                    if (resolution?.retryDetailRevision) {
+                        const retryPatch = Object.fromEntries(Object.entries(updates).map(([key, value]) => [
+                            key,
+                            resolution.retryPatch && Object.prototype.hasOwnProperty.call(resolution.retryPatch, key)
+                                ? resolution.retryPatch[key]
+                                : value,
+                        ]));
+                        const retryStatus = (resolution.retryPatch?.status || status);
+                        durableResult = await mutateTaskStatus(task.id, buildDurablePayload(retryStatus, retryPatch, resolution.retryDetailRevision));
+                        if (durableResult
+                            && (durableResult.state === 'rejected' || durableResult.state === 'failed')
+                            && durableResult.errorCode === 'TASK_DETAIL_REVISION_CONFLICT') {
+                            const secondResolution = await onTaskRevisionConflict?.(task.id, null);
+                            if (secondResolution?.handled) {
+                                setError('');
+                                return;
+                            }
+                        }
+                    }
+                    else if (resolution?.handled) {
+                        setError('');
+                        return;
+                    }
+                }
                 if (durableResult && finishDurableTaskMutation(durableResult, task.id, optimisticPatch, previousTasks, previousArchivedTasks))
                     return;
                 if (!durableResult && durableTaskStatusActivationEnabled) {
@@ -515,15 +558,54 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             return;
         }
         try {
-            const legacyPatch = { ...updates, status, completedAt: optimisticPatch.completedAt };
-            const requestInit = {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(legacyPatch),
+            const legacyPatch = {
+                ...updates,
+                status,
+                completedAt: optimisticPatch.completedAt,
+                ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
             };
-            const res = await fetchCloudTaskRootPatch(`/api/taskforce/task/${task.id}`, requestInit, legacyPatch, task.id, taskHttpObservedPrecondition(task, task.id));
+            let activePatch = legacyPatch;
+            let res;
+            let data = {};
+            for (let attempt = 0;; attempt += 1) {
+                res = await fetchCloudTaskRootPatch(`/api/taskforce/task/${task.id}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(activePatch),
+                }, activePatch, task.id, taskHttpObservedPrecondition(task, task.id));
+                if (res.ok)
+                    break;
+                data = await res.json().catch(() => ({}));
+                if (data.code !== 'TASK_DETAIL_REVISION_CONFLICT')
+                    break;
+                setTasks(previousTasks);
+                setArchivedTasks(previousArchivedTasks);
+                const currentDetailRevision = typeof data?.details?.currentDetailRevision === 'string'
+                    ? data.details.currentDetailRevision
+                    : null;
+                const resolution = await onTaskRevisionConflict?.(task.id, currentDetailRevision);
+                if (attempt === 0 && resolution?.retryDetailRevision) {
+                    const retryPatch = Object.fromEntries(Object.entries(legacyPatch).map(([key, value]) => [
+                        key,
+                        resolution.retryPatch && Object.prototype.hasOwnProperty.call(resolution.retryPatch, key)
+                            ? resolution.retryPatch[key]
+                            : value,
+                    ]));
+                    activePatch = {
+                        ...retryPatch,
+                        expectedDetailRevision: resolution.retryDetailRevision,
+                    };
+                    continue;
+                }
+                if (resolution?.handled) {
+                    setError('');
+                    return;
+                }
+                break;
+            }
             if (!res.ok) {
-                const data = await res.json().catch(() => ({}));
+                if (Object.keys(data).length === 0)
+                    data = await res.json().catch(() => ({}));
                 const message = data.error || 'Failed to update task status.';
                 setError(message);
                 pushNotice(message, 'error');
@@ -532,8 +614,10 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                 return;
             }
             const updatedTask = await res.json().catch(() => null);
-            if (updatedTask)
+            if (updatedTask) {
                 mergeTaskFromServer(updatedTask);
+                onTaskMutationAccepted?.(updatedTask);
+            }
             else
                 await fetchTasks(true);
             queueWorkspaceSyncFromAuthoritativeTaskState();
@@ -549,6 +633,8 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
     }, [
         archivedTasks,
         durableTaskMetadataActivationEnabled,
+        editingTaskDetailRevision,
+        editingTaskId,
         durableTaskHttpRootActivationEnabled,
         durableTaskStatusActivationEnabled,
         fetchTasks,
@@ -556,6 +642,8 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         finishDurableTaskMutation,
         mergeTaskFromServer,
         mutateTaskStatus,
+        onTaskMutationAccepted,
+        onTaskRevisionConflict,
         pushNotice,
         queueWorkspaceSyncFromAuthoritativeTaskState,
         setArchivedTasks,
@@ -564,8 +652,14 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         tasks,
     ]);
     const handleUpdateTask = useCallback(async (id, updates) => {
-        const saveSource = updates.saveSource;
-        updates = Object.fromEntries(Object.entries(updates).filter(([key]) => key !== 'saveSource'));
+        const specialFields = updates;
+        const saveSource = specialFields.saveSource;
+        const expectedDetailRevision = typeof specialFields.expectedDetailRevision === 'string'
+            ? specialFields.expectedDetailRevision
+            : id === editingTaskId
+                ? editingTaskDetailRevision
+                : null;
+        updates = Object.fromEntries(Object.entries(updates).filter(([key]) => (key !== 'saveSource' && key !== 'expectedDetailRevision')));
         if (Object.keys(updates).length === 0)
             return true;
         const authoritativeTask = authoritativeTaskSnapshotsRef.current.get(id);
@@ -589,7 +683,7 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         if (updates.status) {
             const target = tasks.find((task) => task.id === id) || archivedTasks.find((task) => task.id === id);
             if (target) {
-                await handleSetStatus(target, updates.status, updates);
+                await handleSetStatus(target, updates.status, updates, expectedDetailRevision);
                 return;
             }
             if (durableTaskStatusActivationEnabled) {
@@ -610,10 +704,58 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
         let durableMetadataHandled = false;
         if (hasDurableMetadata && mutateTaskMetadata) {
             try {
-                const durableResult = saveSource
-                    ? await mutateTaskMetadata(id, durableMetadataPatch, { saveSource })
+                const initialMutationOptions = {
+                    ...(saveSource ? { saveSource } : {}),
+                    ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
+                };
+                let durableResult = Object.keys(initialMutationOptions).length > 0
+                    ? await mutateTaskMetadata(id, durableMetadataPatch, initialMutationOptions)
                     : await mutateTaskMetadata(id, durableMetadataPatch);
                 if (durableResult && durableResult.state !== 'disabled') {
+                    if ((durableResult.state === 'rejected' || durableResult.state === 'failed')
+                        && durableResult.errorCode === 'TASK_DETAIL_REVISION_CONFLICT') {
+                        const previousTask = previousTasks.find((task) => task.id === id)
+                            || previousArchivedTasks.find((task) => task.id === id);
+                        setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        const resolution = await onTaskRevisionConflict?.(id, null);
+                        if (resolution?.retryDetailRevision) {
+                            const reconciledPatch = resolution.retryPatch;
+                            const retryMetadataPatch = Object.fromEntries(Object.entries(durableMetadataPatch).map(([key, value]) => [
+                                key,
+                                reconciledPatch && Object.prototype.hasOwnProperty.call(reconciledPatch, key)
+                                    ? reconciledPatch[key]
+                                    : value,
+                            ]));
+                            durableResult = await mutateTaskMetadata(id, retryMetadataPatch, {
+                                ...(saveSource ? { saveSource } : {}),
+                                expectedDetailRevision: resolution.retryDetailRevision,
+                            });
+                            if (durableResult
+                                && (durableResult.state === 'rejected' || durableResult.state === 'failed')
+                                && durableResult.errorCode === 'TASK_DETAIL_REVISION_CONFLICT') {
+                                const secondResolution = await onTaskRevisionConflict?.(id, null);
+                                if (secondResolution?.handled) {
+                                    setError('');
+                                    return false;
+                                }
+                            }
+                        }
+                        else if (resolution?.handled) {
+                            setError('');
+                            return false;
+                        }
+                    }
+                    if (!durableResult || durableResult.state === 'disabled') {
+                        const previousTask = previousTasks.find((task) => task.id === id)
+                            || previousArchivedTasks.find((task) => task.id === id);
+                        setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, updates));
+                        const message = 'Task was not saved because durable metadata capture became unavailable during retry.';
+                        setError(message);
+                        pushNotice(message, 'error');
+                        return false;
+                    }
                     if (durableResult.state === 'rejected' || durableResult.state === 'failed') {
                         const previousTask = previousTasks.find((task) => task.id === id)
                             || previousArchivedTasks.find((task) => task.id === id);
@@ -629,8 +771,10 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                         return false;
                     }
                     durableMetadataHandled = true;
-                    if ('task' in durableResult && durableResult.task)
+                    if ('task' in durableResult && durableResult.task) {
                         mergeTaskFromServer(durableResult.task);
+                        onTaskMutationAccepted?.(durableResult.task);
+                    }
                     if (durableResult.state === 'accepted') {
                         setError('');
                     }
@@ -708,32 +852,68 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             const legacyRequestPatch = {
                 ...legacyCarrierPatch,
                 ...(saveSource ? { saveSource } : {}),
+                ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
             };
             const requestInit = {
                 method: 'PATCH',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(legacyRequestPatch),
             };
-            const res = await fetchCloudTaskRootPatch(`/api/taskforce/task/${id}`, requestInit, legacyRequestPatch, id, taskHttpObservedPrecondition(previousTasks.find((task) => task.id === id)
-                || previousArchivedTasks.find((task) => task.id === id), id));
-            if (!res.ok) {
+            let activeRequestPatch = legacyRequestPatch;
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                const activeRequestInit = attempt === 0 ? requestInit : {
+                    ...requestInit,
+                    body: JSON.stringify(activeRequestPatch),
+                };
+                const res = await fetchCloudTaskRootPatch(`/api/taskforce/task/${id}`, activeRequestInit, activeRequestPatch, id, taskHttpObservedPrecondition(previousTasks.find((task) => task.id === id)
+                    || previousArchivedTasks.find((task) => task.id === id), id));
+                if (res.ok) {
+                    const updatedTask = await res.json().catch(() => null);
+                    mergeTaskFromServer(updatedTask);
+                    if (updatedTask && typeof updatedTask === 'object' && typeof updatedTask.id === 'string') {
+                        onTaskMutationAccepted?.(updatedTask);
+                    }
+                    // Attachment saves also depend on the canonical asset snapshot refresh. Give that
+                    // snapshot a brief head start so the next push includes both task metadata and bytes.
+                    queueWorkspaceSyncFromAuthoritativeTaskState(updates.attachments !== undefined ? 150 : 0);
+                    setError('');
+                    return true;
+                }
                 const data = await res.json().catch(() => ({}));
-                const message = data.error || `Failed to update task ${id}.`;
-                setError(message);
-                pushNotice(message, 'error');
                 const previousTask = previousTasks.find((task) => task.id === id)
                     || previousArchivedTasks.find((task) => task.id === id);
                 setTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, legacyCarrierPatch));
                 setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, legacyCarrierPatch));
+                if (data.code === 'TASK_DETAIL_REVISION_CONFLICT') {
+                    const currentDetailRevision = typeof data?.details?.currentDetailRevision === 'string'
+                        ? data.details.currentDetailRevision
+                        : null;
+                    const resolution = await onTaskRevisionConflict?.(id, currentDetailRevision);
+                    if (attempt === 0 && resolution?.retryDetailRevision) {
+                        const reconciledPatch = resolution.retryPatch;
+                        const retryPatch = Object.fromEntries(Object.entries(legacyRequestPatch).map(([key, value]) => [
+                            key,
+                            reconciledPatch && Object.prototype.hasOwnProperty.call(reconciledPatch, key)
+                                ? reconciledPatch[key]
+                                : value,
+                        ]));
+                        activeRequestPatch = {
+                            ...retryPatch,
+                            expectedDetailRevision: resolution.retryDetailRevision,
+                        };
+                        continue;
+                    }
+                    if (resolution?.handled) {
+                        setError('');
+                        return false;
+                    }
+                }
+                const message = data.error || `Failed to update task ${id}.`;
+                setError(message);
+                pushNotice(message, 'error');
                 return false;
             }
-            const updatedTask = await res.json().catch(() => null);
-            mergeTaskFromServer(updatedTask);
-            // Attachment saves also depend on the canonical asset snapshot refresh. Give that
-            // snapshot a brief head start so the next push includes both task metadata and bytes.
-            queueWorkspaceSyncFromAuthoritativeTaskState(updates.attachments !== undefined ? 150 : 0);
-            setError('');
-            return true;
+            return false;
         }
         catch (err) {
             console.error("Failed to update task", err);
@@ -746,7 +926,7 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             setArchivedTasks((currentTasks) => rollbackTargetTaskPatch(currentTasks, previousTask, id, legacyCarrierPatch));
             return false;
         }
-    }, [tasks, archivedTasks, pushNotice, mergeTaskFromServer, mutateTaskMetadata, queueWorkspaceSyncFromAuthoritativeTaskState, handleSetStatus, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, fetchCloudTaskRootPatch]);
+    }, [tasks, archivedTasks, editingTaskDetailRevision, editingTaskId, pushNotice, mergeTaskFromServer, mutateTaskMetadata, onTaskMutationAccepted, onTaskRevisionConflict, queueWorkspaceSyncFromAuthoritativeTaskState, handleSetStatus, durableTaskMetadataActivationEnabled, durableTaskStatusActivationEnabled, fetchCloudTaskRootPatch]);
     const handleToggleComplete = async (task) => {
         const newStatus = task.status === 'done' ? 'task' : 'done';
         await handleSetStatus(task, newStatus);