@umudik/task-bridge 0.0.1

package/apps/backend/dist/services/workflow-service.js

@@ -0,0 +1,418 @@
+import { randomUUID } from "node:crypto";
+import { countWorkflowStages, deleteProjectMemberRow, deleteWorkflowStagesForProject, insertProjectMemberRow, insertWorkflowStageRow, listProjectMemberRows, listProjectWorkflowSettingsRows, listWorkflowStageRows, updateProjectMemberRow, upsertProjectWorkflowSettingsRow, } from "../db/workflow-db.js";
+import { SUBTASK_SPAWN_STAGE_ID, countSpawnableTemplates, parseRulesJson, resolveEpicDescription, resolveStageTaskTemplates, serializeTaskTemplates, stageHasActionableTemplates, } from "../domain/workflow-stage.js";
+import { isDoneStage, listSubtasks } from "../domain/task.js";
+import { AppError } from "../errors/app-error.js";
+import { deleteEpicSubtasks, mutateTaskRow } from "../db/tasks-db.js";
+import { insertEpicRow, listEpicRows } from "../db/epic-workflow-db.js";
+import { allocateTaskId, getBridgeTask, listBridgeTasks, upsertBridgeTask } from "./task-service.js";
+import { pickMemberByProjectRole, resolveTaskAssignee } from "./task-assignee-service.js";
+import { DEFAULT_WORKFLOW_TEMPLATE_ID } from "../domain/workflow-template-id.js";
+import { copyTemplateStagesToProject, getWorkflowTemplate } from "./workflow-template-service.js";
+import { validateStageTransition } from "./workflow-rules.js";
+import { rebuildEpicWorkflowState } from "./workflow-state-service.js";
+function normalizeStageForSave(stage, projectRoles = null) {
+    const taskTemplates = (stage.taskTemplates || []).map((template) => {
+        let assigneeRole = null;
+        let rawRole = "";
+        if (template.assigneeRole) {
+            rawRole = template.assigneeRole;
+        }
+        if (rawRole && (!projectRoles || projectRoles.has(rawRole))) {
+            assigneeRole = rawRole;
+        }
+        return Object.assign({}, template, { assigneeRole });
+    });
+    let autoAssignRole = null;
+    let rawRole = "";
+    if (stage.autoAssignRole) {
+        rawRole = stage.autoAssignRole;
+    }
+    if (rawRole && (!projectRoles || projectRoles.has(rawRole))) {
+        autoAssignRole = rawRole;
+    }
+    return Object.assign({}, stage, {
+        taskTemplates,
+        autoAssignRole,
+        spawnTaskCount: countSpawnableTemplates(taskTemplates),
+    });
+}
+function normalizeProjectRoles(roles) {
+    const seen = new Set();
+    const result = [];
+    for (const role of roles) {
+        if (!role || seen.has(role))
+            continue;
+        seen.add(role);
+        result.push(role);
+    }
+    return result;
+}
+function loadProjectRoles(projectId) {
+    const settingsRows = listProjectWorkflowSettingsRows({ projectId });
+    const firstSettingsRow = settingsRows[0];
+    if (!firstSettingsRow)
+        return [];
+    return normalizeProjectRoles(parseRulesJson(firstSettingsRow.roles_json));
+}
+function rowToStage(row) {
+    const taskTemplates = resolveStageTaskTemplates({
+        taskTemplatesJson: row.task_templates_json,
+        stageId: row.id,
+        stageTitle: row.title,
+    });
+    const autoAssignRole = row.auto_assign_role || null;
+    return {
+        id: row.id,
+        title: row.title,
+        description: resolveEpicDescription({
+            description: row.description,
+            purpose: row.purpose,
+            rulesJson: row.rules_json,
+        }),
+        position: row.position,
+        autoAssignRole,
+        layoutX: row.layout_x,
+        layoutY: row.layout_y,
+        spawnTaskCount: countSpawnableTemplates(taskTemplates),
+        taskTemplates,
+        activeTaskCount: null,
+    };
+}
+function countOpenTasksForMember(tasks, memberName) {
+    return tasks.filter((task) => task.assignee === memberName && !isDoneStage(task.stageId)).length;
+}
+function memberRowToProjectMember(row, tasks) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        name: row.name,
+        role: row.role,
+        openTasks: countOpenTasksForMember(tasks.filter((task) => task.projectId === row.project_id), row.name),
+    };
+}
+export function ensureProjectWorkflow(projectId) {
+    const id = projectId;
+    if (!id)
+        return;
+    if (countWorkflowStages(id) > 0)
+        return;
+    copyTemplateStagesToProject(id, DEFAULT_WORKFLOW_TEMPLATE_ID);
+}
+export function applyWorkflowTemplateToProject(projectId, templateId) {
+    const template = getWorkflowTemplate(templateId);
+    if (!template) {
+        throw new AppError("Workflow template not found", 404);
+    }
+    copyTemplateStagesToProject(projectId, templateId);
+    resetProjectEpicWorkflows(projectId);
+    return getProjectWorkflow(projectId);
+}
+function resetProjectEpicWorkflows(projectId) {
+    const id = projectId;
+    const firstStageId = getFirstStageId(id);
+    const epicIds = new Set();
+    for (const row of listEpicRows({ id: 0, projectId: id })) {
+        epicIds.add(row.id);
+    }
+    const tasks = listBridgeTasks();
+    for (const task of tasks) {
+        if (task.projectId === id && task.parentId === null) {
+            epicIds.add(task.id);
+        }
+    }
+    for (const epicId of epicIds) {
+        deleteEpicSubtasks(epicId);
+        mutateTaskRow(epicId, (task) => {
+            task.stageId = firstStageId;
+            task.claimedBy = null;
+            task.claimedAt = null;
+        });
+        if (listEpicRows({ id: epicId, projectId: "" }).length === 0) {
+            const epicTask = tasks.find((task) => task.id === epicId);
+            if (epicTask) {
+                insertEpicRow({
+                    id: epicId,
+                    projectId: id,
+                    title: epicTask.title,
+                    description: epicTask.description,
+                    stageId: firstStageId,
+                    createdBy: epicTask.createdBy,
+                });
+            }
+        }
+        rebuildEpicWorkflowState(epicId, id, firstStageId);
+    }
+}
+export function getFirstStageId(projectId) {
+    ensureProjectWorkflow(projectId);
+    const rows = listWorkflowStageRows({ projectId, stageId: "" }).sort((a, b) => a.position - b.position);
+    if (rows.length === 0)
+        return null;
+    for (const row of rows) {
+        if (stageHasActionableTemplates({
+            taskTemplatesJson: row.task_templates_json,
+            stageId: row.id,
+            stageTitle: row.title,
+        })) {
+            return row.id;
+        }
+    }
+    const firstRow = rows[0];
+    if (!firstRow)
+        return null;
+    return firstRow.id;
+}
+export function resolveNewTaskPlacement(projectId) {
+    ensureProjectWorkflow(projectId);
+    const stageId = getFirstStageId(projectId);
+    if (!stageId) {
+        const assignee = pickMemberByProjectRole(projectId, "");
+        return { stageId: null, assignee, assigneeRole: null };
+    }
+    const stageRows = listWorkflowStageRows({ projectId, stageId });
+    const row = stageRows[0];
+    if (!row) {
+        const assignee = pickMemberByProjectRole(projectId, "");
+        return { stageId, assignee, assigneeRole: null };
+    }
+    const autoAssignRole = row.auto_assign_role;
+    const resolved = resolveTaskAssignee({
+        projectId,
+        assignee: null,
+        assigneeRole: autoAssignRole || null,
+        stageId,
+    });
+    return { stageId, assignee: resolved.assignee, assigneeRole: resolved.assigneeRole };
+}
+export function getStageTitleLookup(projectId) {
+    const map = new Map();
+    for (const row of listWorkflowStageRows({ projectId, stageId: "" })) {
+        map.set(row.id, row.title);
+    }
+    return map;
+}
+function countActiveTasksForStage(tasks, stageId) {
+    return tasks.filter((task) => task.parentId === null && task.stageId === stageId).length;
+}
+export function getProjectWorkflow(projectId) {
+    ensureProjectWorkflow(projectId);
+    const tasks = listBridgeTasks();
+    const projectTasks = tasks.filter((task) => task.projectId === projectId);
+    const stages = listWorkflowStageRows({ projectId, stageId: "" }).map((row) => {
+        const stage = rowToStage(row);
+        return Object.assign({}, stage, {
+            activeTaskCount: countActiveTasksForStage(projectTasks, stage.id),
+        });
+    });
+    const roles = loadProjectRoles(projectId);
+    const members = listProjectMemberRows({ projectId, id: "" }).map((row) => memberRowToProjectMember(row, tasks));
+    return { projectId, roles, stages, members };
+}
+export function replaceProjectWorkflow(projectId, stages, roles = []) {
+    const id = projectId;
+    if (stages.length < 1) {
+        throw new AppError("At least one workflow stage is required", 400);
+    }
+    const normalizedRoles = normalizeProjectRoles(roles);
+    const roleSet = new Set(normalizedRoles);
+    deleteWorkflowStagesForProject(id);
+    stages.forEach((stage, index) => {
+        const normalized = normalizeStageForSave(stage, roleSet);
+        let position = index;
+        if (normalized.position > 0 || index === 0) {
+            position = normalized.position;
+        }
+        const autoAssignRole = normalized.autoAssignRole || "";
+        insertWorkflowStageRow({
+            id: normalized.id,
+            projectId: id,
+            title: normalized.title,
+            description: normalized.description,
+            purpose: "",
+            rulesJson: "[]",
+            position,
+            autoAssignRole,
+            layoutX: normalized.layoutX,
+            layoutY: normalized.layoutY,
+            spawnTaskCount: normalized.spawnTaskCount,
+            taskTemplatesJson: serializeTaskTemplates(normalized.taskTemplates),
+        });
+    });
+    upsertProjectWorkflowSettingsRow(id, JSON.stringify(normalizedRoles));
+    resetProjectEpicWorkflows(id);
+    return getProjectWorkflow(id);
+}
+export { pickMemberByProjectRole } from "./task-assignee-service.js";
+export function applyStageToTask(task, stageId) {
+    validateStageTransition(task, stageId);
+    const stageRows = listWorkflowStageRows({ projectId: task.projectId, stageId });
+    if (stageRows.length === 0) {
+        throw new AppError("Unknown stage", 400);
+    }
+    const stage = stageRows[0];
+    if (!stage)
+        throw new AppError("Unknown stage", 400);
+    const autoAssignRole = stage.auto_assign_role;
+    return resolveTaskAssignee({
+        projectId: task.projectId,
+        assignee: null,
+        assigneeRole: autoAssignRole || task.assigneeRole,
+        stageId,
+    });
+}
+export function spawnStageSubtasks(parent, stageId) {
+    if (parent.parentId !== null)
+        return [];
+    if (stageId !== SUBTASK_SPAWN_STAGE_ID)
+        return [];
+    const stageRows = listWorkflowStageRows({ projectId: parent.projectId, stageId });
+    if (stageRows.length === 0)
+        return [];
+    const row = stageRows[0];
+    if (!row)
+        return [];
+    const templates = resolveStageTaskTemplates({
+        taskTemplatesJson: row.task_templates_json,
+        stageId: row.id,
+        stageTitle: row.title,
+    });
+    if (templates.length === 0)
+        return [];
+    const tasks = listBridgeTasks();
+    const existing = listSubtasks(tasks, parent.id);
+    if (existing.length >= templates.length)
+        return [];
+    const created = [];
+    for (let i = existing.length; i < templates.length; i += 1) {
+        const template = templates[i];
+        if (!template)
+            continue;
+        let assignee = null;
+        let templateRole = "";
+        if (template.assigneeRole) {
+            templateRole = template.assigneeRole;
+        }
+        if (templateRole) {
+            assignee = pickMemberByProjectRole(parent.projectId, templateRole);
+        }
+        else {
+            const autoAssignRole = row.auto_assign_role;
+            if (autoAssignRole) {
+                assignee = pickMemberByProjectRole(parent.projectId, autoAssignRole);
+            }
+        }
+        const id = allocateTaskId();
+        const task = upsertBridgeTask({
+            id,
+            projectId: parent.projectId,
+            projectName: parent.projectName,
+            title: template.title,
+            description: template.description,
+            createdBy: "workflow",
+            createdAt: null,
+            parentId: parent.id,
+            epicId: null,
+            stageId,
+            assignee,
+            assigneeRole: template.assigneeRole,
+            assigneeKind: null,
+            templateId: template.id,
+            workStatus: "todo",
+        });
+        created.push(task);
+    }
+    return created;
+}
+export function getStageSnapshot(projectId, stageId) {
+    if (!stageId)
+        return null;
+    ensureProjectWorkflow(projectId);
+    const stageRows = listWorkflowStageRows({ projectId, stageId });
+    if (stageRows.length === 0)
+        return null;
+    const row = stageRows[0];
+    if (!row)
+        return null;
+    const stage = rowToStage(row);
+    return {
+        id: stage.id,
+        title: stage.title,
+        description: stage.description,
+        spawnTaskCount: stage.spawnTaskCount,
+        taskTemplates: stage.taskTemplates,
+    };
+}
+export function createProjectMember(input) {
+    const id = randomUUID();
+    insertProjectMemberRow({
+        id,
+        projectId: input.projectId,
+        name: input.name,
+        role: input.role,
+    });
+    const memberRows = listProjectMemberRows({ projectId: "", id });
+    if (memberRows.length === 0)
+        throw new Error("Failed to create member");
+    const row = memberRows[0];
+    if (!row)
+        throw new Error("Failed to create member");
+    const tasks = listBridgeTasks();
+    return memberRowToProjectMember(row, tasks);
+}
+export function updateProjectMember(id, patch) {
+    if (!updateProjectMemberRow(id, patch)) {
+        return null;
+    }
+    const memberRows = listProjectMemberRows({ projectId: "", id });
+    if (memberRows.length === 0)
+        return null;
+    const row = memberRows[0];
+    if (!row)
+        return null;
+    const tasks = listBridgeTasks();
+    return memberRowToProjectMember(row, tasks);
+}
+export function removeProjectMember(id) {
+    return deleteProjectMemberRow(id);
+}
+export function exportWorkflowReadable(projectId) {
+    const workflow = getProjectWorkflow(projectId);
+    return {
+        projectId: workflow.projectId,
+        roles: workflow.roles,
+        stages: workflow.stages.map((stage) => ({
+            id: stage.id,
+            title: stage.title,
+            description: stage.description,
+            autoAssignRole: stage.autoAssignRole || "",
+            spawnTaskCount: stage.spawnTaskCount,
+            taskTemplates: stage.taskTemplates,
+        })),
+        members: workflow.members.map((member) => ({
+            id: member.id,
+            name: member.name,
+            role: member.role,
+            openTasks: member.openTasks,
+        })),
+    };
+}
+export function enrichTaskWithWorkflow(task) {
+    if (!task)
+        return null;
+    const stage = getStageSnapshot(task.projectId, task.stageId);
+    return {
+        stageId: task.stageId,
+        stage,
+        assignee: task.assignee,
+    };
+}
+export function validateTaskBelongsToProject(taskId, projectId) {
+    const task = getBridgeTask(taskId);
+    if (!task)
+        return null;
+    if (task.projectId !== projectId) {
+        throw new AppError("Task not found", 404);
+    }
+    return task;
+}

package/apps/backend/dist/services/workflow-spawn-service.js

@@ -0,0 +1,179 @@
+import { listWorkflowStageRows } from "../db/workflow-db.js";
+import { collectSpawnableTemplates, } from "../domain/task-template-graph.js";
+import { isWorkDone } from "../domain/work-status.js";
+import { listEpicWorkflowTasks } from "../domain/task.js";
+import { resolveStageTaskTemplateRoots, stageHasActionableTemplates, } from "../domain/workflow-stage.js";
+import { emptyToNull } from "../lib/strings.js";
+import { mutateTaskRow } from "../db/tasks-db.js";
+import { applyWorkflowStateNodeToTaskInput, linkSpawnedTemplateTask, loadEpicWorkflowState, spawnContextFromWorkflowState, syncTaskIntoWorkflowState, } from "./workflow-state-service.js";
+import { computeEpicStageId } from "./epic-service.js";
+import { allocateTaskId, listBridgeTasks, upsertBridgeTask } from "./task-service.js";
+import { pickMemberByProjectRole } from "./workflow-service.js";
+function buildSpawnContext(stageRow, workflowTasks, stageRows, epicId) {
+    const state = loadEpicWorkflowState(epicId);
+    let activeStageId;
+    if (state !== null && state.stageId !== null) {
+        activeStageId = state.stageId;
+    }
+    else {
+        activeStageId = computeEpicStageId(stageRows, workflowTasks);
+    }
+    let activeStage = stageRow;
+    for (const stage of stageRows) {
+        if (stage.id === activeStageId) {
+            activeStage = stage;
+            break;
+        }
+    }
+    let spawnedTemplateIds;
+    let doneTemplateIds;
+    if (state) {
+        const fromState = spawnContextFromWorkflowState(state);
+        spawnedTemplateIds = fromState.spawnedTemplateIds;
+        doneTemplateIds = fromState.doneTemplateIds;
+    }
+    else {
+        spawnedTemplateIds = new Set(workflowTasks
+            .map((task) => task.templateId)
+            .filter((templateId) => Boolean(templateId)));
+        doneTemplateIds = new Set(workflowTasks
+            .filter((task) => task.templateId !== null && isWorkDone(task))
+            .map((task) => task.templateId));
+    }
+    return {
+        stageId: stageRow.id,
+        stagePosition: stageRow.position,
+        activeStagePosition: activeStage.position,
+        spawnedTemplateIds,
+        doneTemplateIds,
+    };
+}
+function spawnTemplateTask(input) {
+    const templateRole = emptyToNull(input.template.assigneeRole);
+    const stageRole = emptyToNull(input.stageRow.auto_assign_role);
+    let assigneeRole;
+    if (templateRole !== null) {
+        assigneeRole = templateRole;
+    }
+    else {
+        assigneeRole = stageRole;
+    }
+    let assignee;
+    if (assigneeRole !== null) {
+        assignee = pickMemberByProjectRole(input.epic.projectId, assigneeRole);
+    }
+    else {
+        assignee = null;
+    }
+    const id = allocateTaskId();
+    let description;
+    if (input.template.description !== null) {
+        description = input.template.description;
+    }
+    else {
+        description = "";
+    }
+    const nodeDefaults = applyWorkflowStateNodeToTaskInput(input.epic.id, input.template.id, {
+        workStatus: "todo",
+        comments: [],
+    });
+    const task = upsertBridgeTask({
+        id,
+        projectId: input.epic.projectId,
+        projectName: input.epic.projectName,
+        title: input.template.title,
+        description,
+        createdBy: "workflow",
+        createdAt: null,
+        parentId: input.parentTaskId,
+        epicId: input.epic.id,
+        templateId: input.template.id,
+        stageId: input.stageRow.id,
+        assignee,
+        assigneeRole,
+        assigneeKind: null,
+        workStatus: nodeDefaults.workStatus,
+    });
+    if (nodeDefaults.comments.length > 0 || nodeDefaults.workStatus !== "todo") {
+        mutateTaskRow(id, (row) => {
+            row.comments = nodeDefaults.comments.slice();
+            row.workStatus = nodeDefaults.workStatus;
+        });
+    }
+    linkSpawnedTemplateTask(input.epic.id, input.template.id, id);
+    const refreshed = listBridgeTasks().find((entry) => entry.id === id);
+    if (refreshed) {
+        syncTaskIntoWorkflowState(refreshed);
+        return refreshed;
+    }
+    return task;
+}
+function resolveParentTaskId(epic, workflowTasks, templateParentId) {
+    if (!templateParentId)
+        return epic.id;
+    for (const task of workflowTasks) {
+        if (task.templateId === templateParentId) {
+            return task.id;
+        }
+    }
+    return epic.id;
+}
+function findTemplateParentId(nodes, templateId, parentTemplateId = null) {
+    for (const node of nodes) {
+        if (node.id === templateId)
+            return parentTemplateId;
+        if (node.children.length > 0) {
+            const nextParent = node.id;
+            const found = findTemplateParentId(node.children, templateId, nextParent);
+            if (found !== null)
+                return found;
+        }
+    }
+    return null;
+}
+export function spawnUnlockedWorkflowTasks(epic) {
+    if (epic.parentId !== null)
+        return [];
+    const rows = listWorkflowStageRows({ projectId: epic.projectId, stageId: "" }).sort((a, b) => a.position - b.position);
+    const allTasks = listBridgeTasks();
+    const workflowTasks = listEpicWorkflowTasks(allTasks, epic.id);
+    const created = [];
+    for (const row of rows) {
+        const templateInput = {
+            taskTemplatesJson: row.task_templates_json,
+            stageId: row.id,
+            stageTitle: row.title,
+        };
+        if (!stageHasActionableTemplates(templateInput))
+            continue;
+        const roots = resolveStageTaskTemplateRoots(templateInput);
+        const ctx = buildSpawnContext(row, workflowTasks.concat(created), rows, epic.id);
+        let progressed = true;
+        while (progressed) {
+            progressed = false;
+            const spawnable = collectSpawnableTemplates(roots, ctx);
+            for (const template of spawnable) {
+                const templateParentId = findTemplateParentId(roots, template.id);
+                const parentTaskId = resolveParentTaskId(epic, workflowTasks.concat(created), templateParentId);
+                const task = spawnTemplateTask({
+                    epic,
+                    stageRow: row,
+                    template: {
+                        id: template.id,
+                        title: template.title,
+                        description: template.description,
+                        assigneeRole: template.assigneeRole,
+                    },
+                    parentTaskId,
+                });
+                created.push(task);
+                ctx.spawnedTemplateIds.add(template.id);
+                progressed = true;
+            }
+        }
+    }
+    return created;
+}
+export function spawnEpicWorkflowGraph(epic) {
+    return spawnUnlockedWorkflowTasks(epic);
+}