1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
import { useState, useCallback, useEffect } from "react";
import {
listTasks,
getTask,
createTask,
updateTask,
deleteTask,
VersionConflictError,
type TaskSummary,
type TaskWithSubtasks,
type CreateTaskRequest,
type UpdateTaskRequest,
} from "../lib/api";
export interface ConflictState {
hasConflict: boolean;
expectedVersion: number;
actualVersion: number;
}
export function useTasks() {
const [tasks, setTasks] = useState<TaskSummary[]>([]);
const [loading, setLoading] = useState(false);
const [error, setError] = useState<string | null>(null);
const [conflict, setConflict] = useState<ConflictState | null>(null);
const fetchTasks = useCallback(async () => {
setLoading(true);
setError(null);
try {
const response = await listTasks();
setTasks(response.tasks);
} catch (e) {
setError(e instanceof Error ? e.message : "Failed to fetch tasks");
} finally {
setLoading(false);
}
}, []);
const fetchTask = useCallback(
async (id: string): Promise<TaskWithSubtasks | null> => {
setError(null);
try {
return await getTask(id);
} catch (e) {
setError(e instanceof Error ? e.message : "Failed to fetch task");
return null;
}
},
[]
);
const saveTask = useCallback(
async (data: CreateTaskRequest): Promise<TaskWithSubtasks | null> => {
setError(null);
try {
const task = await createTask(data);
await fetchTasks(); // Refresh list
// Return as TaskWithSubtasks
return { ...task, subtasks: [] };
} catch (e) {
setError(e instanceof Error ? e.message : "Failed to save task");
return null;
}
},
[fetchTasks]
);
const editTask = useCallback(
async (id: string, data: UpdateTaskRequest): Promise<TaskWithSubtasks | null> => {
setError(null);
setConflict(null);
try {
await updateTask(id, data);
await fetchTasks(); // Refresh list
// Re-fetch to get subtasks
return await getTask(id);
} catch (e) {
if (e instanceof VersionConflictError) {
setConflict({
hasConflict: true,
expectedVersion: e.expectedVersion,
actualVersion: e.actualVersion,
});
return null;
}
setError(e instanceof Error ? e.message : "Failed to update task");
return null;
}
},
[fetchTasks]
);
const clearConflict = useCallback(() => {
setConflict(null);
}, []);
const removeTask = useCallback(
async (id: string): Promise<boolean> => {
setError(null);
try {
await deleteTask(id);
await fetchTasks(); // Refresh list
return true;
} catch (e) {
setError(e instanceof Error ? e.message : "Failed to delete task");
return false;
}
},
[fetchTasks]
);
// Initial fetch
useEffect(() => {
fetchTasks();
}, [fetchTasks]);
return {
tasks,
loading,
error,
conflict,
clearConflict,
fetchTasks,
fetchTask,
saveTask,
editTask,
removeTask,
};
}
|
