TaskView is a self-hosted project and task management platform focused on clarity, ownership, and control. TaskView is built for teams that want a transparent, self-hosted alternative to SaaS task managers.
TypeScript graphviewkanban-boardnodejsproductivityproject-managementself-hostedtasktask-managementtask-managertodoapp
import type { TasksSchemaTypeForSelect } from 'taskview-db-schemas';
import type { AppUser } from '../../core/AppUser';
import { $logger } from '../../modules/logget';
import { eventBus } from '../../core/EventBus';
import { GoalPermissions } from '../../types/auth.types';
import type {
AddTaskArg,
FetchAssignedUsersArg,
// FetchSubtasksArg,
// FetchTaskHistoryArg,
FetchTasksArg,
MoveTaskArg,
TaskDatesFromDb,
TaskFetchTaskById,
// TaskRecoverHistoryStateArg,
TasksUpdateStatusId,
TaskUpdateAmount,
TaskUpdateOrders,
TaskUpdateTransactionType,
UpdatePriorityArg,
UpdateTaskAssigneeArg,
UpdateTaskCheckedArg,
UpdateTaskDeadlineArg,
UpdateTaskDescriptionArg,
UpdateTaskNoteArg,
} from '../../types/tasks.types';
import { TaskItemForClient } from './TaskItemForClient';
import { TaskMovePlanner } from './TaskMovePlanner';
import { TaskMoveRepository } from './TaskMoveRepository';
import { TasksRepository } from './TasksRepository';
import type { TaskArgMove, TaskMoveOutcome, TaskMovePreviewDto } from './task-move.types';
import { FilesRepository } from '../files/FilesRepository';
import {
type TaskAddResult,
type TaskArgAdd,
type TaskArgDelete,
type TaskArgFetchTaskByIdNew,
type TaskArgFetchTaskHistory,
type TaskArgFetchTasksNew,
type TaskArgRestoreTaskHistory,
type TaskArgUpdate,
type TaskForClientNew,
type TaskUpdateResult,
type TasksArgToggleTaskUsers,
} from './tasks.server.types';
import type { KanbanArgFetchTasksForColumn, KanbanArgFilters } from '../kanban/types';
import { hideUnwatchableTaskFields } from './task-field-visibility';
export class TasksManager {
public readonly repository: TasksRepository;
private readonly user: AppUser;
constructor(user: AppUser) {
this.user = user;
this.repository = new TasksRepository();
}
/** @deprecated */
async fetchTaskById(data: TaskFetchTaskById): Promise<TaskItemForClient | null> {
const task = await this.repository.fetchTaskById(data.taskId);
if (!task) return null;
const tags = await this.repository.fetchTagsForTasks([task.id]);
let tagIds: number[] = [];
if (tags) {
tagIds = tags.map((t) => t.tag_id);
}
return new TaskItemForClient(task, tagIds) ?? null;
}
/** @deprecated */
async updateOrdersForTask(orderData: TaskUpdateOrders): Promise<boolean> {
return this.repository.updateOrdersForTask(orderData);
}
/** @deprecated */
async fetchAllTasks(data: FetchTasksArg): Promise<TaskItemForClient[]> {
const tasks = await this.repository.fetchAllTasks(data);
if (!tasks) {
return [];
}
const tagsMap: Record<number, number[]> = {};
const ids = tasks.map((t) => t.id);
const tags = await this.repository.fetchTagsForTasks(ids);
if (tags) {
tags.forEach((item) => {
if (!tagsMap[item.task_id]) {
tagsMap[item.task_id] = [];
}
tagsMap[item.task_id].push(item.tag_id);
});
}
const assigneesMap: Record<number, number[]> = {};
(await this.repository.fetchTaskAssigneeForTasks(ids)).forEach((a) => {
if (!assigneesMap[a.task_id]) {
assigneesMap[a.task_id] = [];
}
assigneesMap[a.task_id].push(a.collab_user_id);
});
const tasksForClient = tasks.map((t) => new TaskItemForClient(t, tagsMap[t.id], null, assigneesMap[t.id]));
return tasksForClient;
}
async fetchTasks(data: FetchTasksArg): Promise<TaskItemForClient[]> {
const tasks = await this.repository.fetchTasks(data);
if (!tasks) {
return [];
}
const tagsMap: Record<number, number[]> = {};
const ids = tasks.map((t) => t.id);
const tags = await this.repository.fetchTagsForTasks(ids);
if (tags) {
tags.forEach((item) => {
if (!tagsMap[item.task_id]) {
tagsMap[item.task_id] = [];
}
tagsMap[item.task_id].push(item.tag_id);
});
}
const assigneesMap: Record<number, number[]> = {};
(await this.repository.fetchTaskAssigneeForTasks(ids)).forEach((a) => {
if (!assigneesMap[a.task_id]) {
assigneesMap[a.task_id] = [];
}
assigneesMap[a.task_id].push(a.collab_user_id);
});
const tasksForClient = tasks.map((t) => new TaskItemForClient(t, tagsMap[t.id], null, assigneesMap[t.id]));
return tasksForClient;
}
async addTask(arg: AddTaskArg): Promise<TaskItemForClient | false> {
const task = await this.repository.addTask(arg, this.user.getUserData()?.id as number);
if (!task) {
return false;
}
return new TaskItemForClient(task);
}
async updateChecked(arg: UpdateTaskCheckedArg): Promise<TaskItemForClient | false> {
const task = await this.repository.updateTaskComplete(arg.taskId, arg.complete);
if (!task) return false;
// Sync task completion state to linked GitHub/GitLab issue
this.user.integrationsManager.onTaskCompleteChanged(arg.taskId, arg.complete).catch(() => { });
return new TaskItemForClient(task);
}
/** @deprecated use deleteTaskNew instead */
async deleteTask(taskId: number): Promise<boolean> {
return await this.repository.deleteTask(taskId);
}
async updateDescription(arg: UpdateTaskDescriptionArg) {
const task = await this.repository.updateTaskDescription(arg.taskId, arg.description);
if (!task) {
return false;
}
return new TaskItemForClient(task);
}
async updateTaskNote(arg: UpdateTaskNoteArg): Promise<boolean> {
return await this.repository.updateTaskNote(arg.taskId, arg.note);
}
async updateDeadline(data: UpdateTaskDeadlineArg): Promise<TaskDatesFromDb | false> {
const result = await this.repository.updateTaskDate(data.taskId, data.data, data.status);
if (!result) {
$logger.error(data, `Can not update task dates`);
}
return await this.repository.getTaskDeadlineDates(data.taskId);
}
// /** @deprecated */
// async fetchSubtasks(data: FetchSubtasksArg): Promise<TaskItemForClient[]> {
// const subtasks = await this.repository.fetchSubtasks(data.taskId);
// return subtasks.map((t) => new TaskItemForClient(t));
// }
async updatePriority(data: UpdatePriorityArg): Promise<boolean> {
return await this.repository.updatePriority(data.taskId, data.priorityId);
}
async moveTask(data: MoveTaskArg): Promise<boolean> {
if (data.listId !== null) {
const listIds = await this.repository.fetchAllowedListIdsForTask(data.taskId);
if (!listIds.includes(data.listId)) return false;
}
return await this.repository.moveTask(data.taskId, data.listId);
}
async fetchAssignedUsers(data: FetchAssignedUsersArg) {
return await this.repository.fetchTaskAssignee(data.taskId);
}
async fetchTaskHistory(
data: TaskArgFetchTaskHistory
): Promise<(TasksSchemaTypeForSelect & { historyId: number | null })[]> {
const history = await this.repository.fetchTaskHistory(data.taskId);
if (!history || history.length === 0) return [];
const toCamel = (str: string) => str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
const normalizeKeys = <T extends object>(obj: T): any =>
Object.fromEntries(
Object.entries(obj).map(([k, v]) => [toCamel(k), v && typeof v === 'object' ? normalizeKeys(v) : v])
);
const normalizedHistory: (TasksSchemaTypeForSelect & { historyId: number | null })[] = history.map((item) => {
return normalizeKeys({ ...item.task, history_id: item.history_id });
});
return normalizedHistory;
}
async recoverTaskHistory(data: TaskArgRestoreTaskHistory) {
return await this.repository.recoveryTaskHistory(data.historyId, data.taskId);
}
async updateTaskAssignee(data: UpdateTaskAssigneeArg) {
const result = await this.repository.updateTaskAssignee(data.taskId, data.usersIds);
if (!result) {
$logger.error('Can not update task assignee');
return false;
}
return data.usersIds;
}
async updateTaskStatusId(data: TasksUpdateStatusId): Promise<boolean> {
const result = await this.repository.updateTaskStatusId(data);
if (!result) {
$logger.error(`Can not update task statusId ${data}`);
}
return result;
}
async updateAmount(data: TaskUpdateAmount): Promise<boolean> {
return await this.repository.updateAmount(data);
}
async updateTransactionType(data: TaskUpdateTransactionType): Promise<boolean> {
return await this.repository.updateTransactionType(data);
}
async updateTask(data: TaskArgUpdate): Promise<TaskUpdateResult> {
const currentTask = await this.repository.fetchTaskByIdNew(data.id);
if (!currentTask) return { ok: false, reason: 'not_found' };
const foreign = await this.repository.referencesOutsideGoal({
taskId: data.id,
goalId: currentTask.goalId,
goalListId: data.goalListId,
statusId: data.statusId,
parentId: data.parentId,
});
if (foreign) return { ok: false, reason: 'foreign_reference' };
if (data.statusId !== undefined && currentTask.statusId !== data.statusId) {
data.kanbanOrder = await this.repository.getNextKanbanOrder(currentTask.goalId);
}
const task = await this.repository.updateTask(data);
if (!task) return { ok: false, reason: 'not_found' };
let syncFailed = false;
if (data.complete !== undefined) {
const synced = await this.user.integrationsManager.onTaskCompleteChanged(data.id, data.complete).catch(() => false);
if (!synced) syncFailed = true;
}
const { id, ...changes } = data;
eventBus.emit('task.updated', {
task,
changes,
initiatorId: this.user.getUserData()?.id as number,
});
const tasks = await this.extendTasksWithTagsAndAssignees([task]);
const result = tasks[0] ?? null;
if (!result) return { ok: false, reason: 'not_found' };
return { ok: true, task: result, syncFailed: syncFailed || undefined };
}
async fetchTasksNew(data: TaskArgFetchTasksNew) {
const tasks = await this.repository.fetch(data);
if (!tasks) return [];
return await this.extendTasksWithTagsAndAssignees(tasks);
}
async fetchTaskByIdNew(data: TaskArgFetchTaskByIdNew) {
const task = await this.repository.fetchTaskByIdNew(data.taskId);
if (!task) return null;
const extendedTask = await this.extendTasksWithTagsAndAssignees([task]);
return extendedTask[0] ?? null;
}
/** Public: other modules returning task rows (e.g. recurrence) gate fields through the same cleaner. */
async cleanTaskFieldsRegardPermissions(task: TasksSchemaTypeForSelect): Promise<TasksSchemaTypeForSelect> {
const checker = await this.user.permissionsFetcher.getCheckerForGoal(task.goalId);
return hideUnwatchableTaskFields({ task, checker });
}
/**
* //TODO CHECK PERMISSIONS FOR ALL FIELDS OF TASK
* Extend tasks with tags and assignees
* @param tasks
* @returns
*/
async extendTasksWithTagsAndAssignees(
tasks: TasksSchemaTypeForSelect[],
justCreated: boolean = false
): Promise<TaskForClientNew[]> {
if (!tasks || tasks.length === 0) {
return [];
}
if (justCreated) {
// TODO check permissions for task field here
return await Promise.all(
tasks.map(async (t) => ({
...(await this.cleanTaskFieldsRegardPermissions(t)),
tags: [],
assignedUsers: [],
historyId: null,
subtasks: [],
filesCount: 0,
}))
);
}
const tagsMap = new Map<number, number[]>();
const assigneesMap = new Map<number, number[]>();
const ids = tasks.map((t) => t.id);
const taskPermissions = await this.user.permissionsFetcher.getCheckerForGoal(tasks[0].goalId);
const [tags, assignees, filesCount] = await Promise.all([
taskPermissions.hasPermissions(GoalPermissions.TASKS_CAN_WATCH_TAGS)
? this.repository.fetchTagsForTasks(ids)
: Promise.resolve([]),
taskPermissions.hasPermissions(GoalPermissions.TASKS_CAN_WATCH_ASSIGNED_USERS)
? this.repository.fetchTaskAssigneeForTasks(ids)
: Promise.resolve([]),
taskPermissions.hasPermissions(GoalPermissions.FILE_CAN_VIEW)
? new FilesRepository().countForTasks(ids)
: Promise.resolve(new Map<number, number>()),
]);
tags.forEach((item) => {
if (!tagsMap.get(item.task_id)) {
tagsMap.set(item.task_id, []);
}
tagsMap.get(item.task_id)?.push(item.tag_id);
});
assignees.forEach((a) => {
if (!assigneesMap.get(a.task_id)) {
assigneesMap.set(a.task_id, []);
}
assigneesMap.get(a.task_id)?.push(a.collab_user_id);
});
return await Promise.all(
tasks.map(async (t) => ({
...(await this.cleanTaskFieldsRegardPermissions(t)),
tags: tagsMap.get(t.id) || [],
assignedUsers: assigneesMap.get(t.id) || [],
historyId: null,
filesCount: filesCount.get(t.id) ?? 0,
//subtasks should be without subtasks, tags and assignees
subtasks: await this.extendTasksWithTagsAndAssignees(
taskPermissions.hasPermissions(GoalPermissions.TASKS_CAN_WATCH_SUBTASKS)
? await this.repository.fetchSubtasks(t.id)
: await Promise.resolve([]),
true
),
}))
);
}
async addTaskNew(data: TaskArgAdd): Promise<TaskAddResult> {
// The caller is authorized on data.goalId only; a DB trigger would otherwise move the task into the list's project
const foreign = await this.repository.referencesOutsideGoal({
taskId: null,
goalId: data.goalId,
goalListId: data.goalListId,
statusId: data.statusId,
parentId: data.parentId,
});
if (foreign) return { ok: false, reason: 'foreign_reference' };
const newData = { ...data };
if (data.kanbanOrder === null || data.kanbanOrder === undefined) {
newData.kanbanOrder = await this.repository.getNextKanbanOrder(data.goalId, data.statusId ?? null);
}
const task = await this.repository.addTaskNew({
data: newData,
creatorId: this.user.getUserData()?.id as number,
});
const result = await this.extendTasksWithTagsAndAssignees(task, true);
if (task[0]) {
eventBus.emit('task.created', {
task: task[0],
initiatorId: this.user.getUserData()?.id as number,
});
}
return { ok: true, tasks: result };
}
async deleteTaskNew(data: TaskArgDelete) {
const task = await this.repository.fetchTaskByIdNew(data.taskId);
const result = await this.repository.deleteTaskNew(data);
if (result) {
eventBus.emit('task.deleted', { taskId: data.taskId, goalId: task?.goalId ?? 0, initiatorId: this.user.getUserData()?.id as number });
}
return result;
}
async toggleTaskUsers(data: TasksArgToggleTaskUsers) {
const result = await this.repository.toggleTaskUsers(data);
eventBus.emit('task.assigneesChanged', {
taskId: data.taskId,
userIds: data.userIds,
initiatorId: this.user.getUserData()?.id as number,
});
return result;
}
async previewMoveToProject(args: TaskArgMove): Promise<TaskMovePreviewDto> {
const planner = this.movePlanner();
return planner.toPreview(await planner.plan(args));
}
async moveToProject(args: TaskArgMove): Promise<TaskMoveOutcome> {
const decision = await this.movePlanner().plan(args);
if (!decision.ok) return decision;
const { plan } = decision;
const initiatorId = this.user.getUserData()?.id as number;
const repository = new TaskMoveRepository();
if (plan.mode === 'copy') {
const copy = await repository.executeCopy({ plan, creatorId: initiatorId });
for (const task of copy.tasks) eventBus.emit('task.created', { task, initiatorId });
return { ok: true, data: { mode: 'copy', taskId: copy.rootTaskId, goalId: plan.targetGoalId } };
}
const task = await repository.executeMove({ plan });
if (!task) return { ok: false, reason: 'not_found' };
eventBus.emit('task.moved', { task, taskIds: plan.taskIds, fromGoalId: plan.sourceGoalId, toGoalId: plan.targetGoalId, initiatorId });
return { ok: true, data: { mode: 'move', taskId: task.id, goalId: plan.targetGoalId } };
}
private movePlanner(): TaskMovePlanner {
return new TaskMovePlanner({
repository: new TaskMoveRepository(),
userId: this.user.getUserData()?.id as number,
checkerForGoal: (goalId) => this.user.permissionsFetcher.getCheckerForGoal(goalId),
});
}
async fetchTasksForKanbanColumn(data: KanbanArgFetchTasksForColumn & { filters?: KanbanArgFilters }): Promise<{ tasks: TaskForClientNew[], nextCursor: string | number | null }> {
const tasks = await this.repository.fetchTasksForKanbanColumn(data.goalId, data.columnId, data.cursor, data.filters);
if (!tasks || tasks.length === 0) return { tasks: [], nextCursor: null };
return { tasks: await this.extendTasksWithTagsAndAssignees(tasks), nextCursor: tasks[tasks.length - 1].kanbanOrder };
}
}