@umudik/task-bridge 0.0.1

package/apps/backend/dist/mappers/task-response.js

@@ -0,0 +1,261 @@
+import { canonicalDescription, isDoneStage, isTaskClaimed, listEpicWorkflowTasks, listSubtasks, resolveTaskStageId, } from "../domain/task.js";
+import { isWorkDone, resolveWorkStatus, workStatusLabel } from "../domain/work-status.js";
+import { syncEpicStage } from "../services/epic-service.js";
+import { listTaskLibraryLinks } from "../services/library-service.js";
+import { getStageSnapshot, getStageTitleLookup } from "../services/workflow-service.js";
+import { AppError } from "../errors/app-error.js";
+import { decodeInboxCursor, encodeInboxCursor, inboxItemBeforeCursor, } from "../lib/inbox-cursor.js";
+import { listBridgeTasks } from "../services/task-service.js";
+import { listWorkflowStateSummaries } from "../services/workflow-state-service.js";
+function latestCommentByRole(comments, role) {
+    for (let index = comments.length - 1; index >= 0; index -= 1) {
+        const entry = comments[index];
+        if (!entry)
+            continue;
+        if (entry.role === role)
+            return entry;
+    }
+    return null;
+}
+export function consumerStatus(task) {
+    if (!task)
+        return "sent";
+    if (isTaskClaimed(task))
+        return "sent";
+    if (isWorkDone(task))
+        return "ready";
+    const lastUser = latestCommentByRole(task.comments, "user");
+    const lastSystem = latestCommentByRole(task.comments, "system");
+    if (lastUser !== null && lastSystem !== null) {
+        const userAt = Date.parse(lastUser.at);
+        const systemAt = Date.parse(lastSystem.at);
+        if (!Number.isNaN(userAt) && !Number.isNaN(systemAt) && userAt > systemAt) {
+            return "sent";
+        }
+    }
+    if (lastSystem !== null)
+        return "ready";
+    if (lastUser !== null && lastUser.authorId !== task.createdBy)
+        return "ready";
+    return "sent";
+}
+export function mapComments(task) {
+    return task.comments.map((comment) => ({
+        id: comment.id,
+        role: comment.role,
+        authorId: comment.authorId,
+        tags: comment.tags,
+        body: comment.body,
+        at: comment.at,
+        metadata: comment.metadata,
+        by: comment.authorId,
+        text: comment.body,
+    }));
+}
+function previewForTask(task) {
+    const lastComment = task.comments[task.comments.length - 1];
+    if (!lastComment)
+        return null;
+    const text = lastComment.body;
+    if (!text)
+        return null;
+    if (text.length > 160)
+        return `${text.slice(0, 157)}...`;
+    return text;
+}
+function resolveStageTitle(stageId, projectId, stageTitles) {
+    if (stageId === null)
+        return null;
+    const fromMap = stageTitles.get(`${projectId}:${stageId}`);
+    if (fromMap)
+        return fromMap;
+    return stageId;
+}
+function mapSubtaskSummary(task, stageTitles, allTasks) {
+    const resolvedStage = resolveTaskStageId(allTasks, task);
+    let stageId = task.stageId;
+    if (resolvedStage !== null) {
+        stageId = resolvedStage;
+    }
+    const stageTitle = resolveStageTitle(stageId, task.projectId, stageTitles);
+    const workStatus = resolveWorkStatus(task);
+    return {
+        taskId: task.id,
+        parentId: task.parentId,
+        title: task.title,
+        stageId,
+        stageTitle,
+        templateId: task.templateId,
+        assignee: task.assignee,
+        claimedBy: task.claimedBy,
+        workStatus,
+        workStatusLabel: workStatusLabel(workStatus),
+        done: workStatus === "done",
+    };
+}
+export function mapTaskDetail(task) {
+    if (task.parentId === null) {
+        syncEpicStage(task.id);
+        const refreshed = listBridgeTasks().find((entry) => entry.id === task.id);
+        if (refreshed)
+            task = refreshed;
+    }
+    const stage = getStageSnapshot(task.projectId, task.stageId);
+    const allTasks = listBridgeTasks();
+    const stageTitles = getStageTitleLookup(task.projectId);
+    let workflowSubtasks;
+    if (task.parentId === null) {
+        workflowSubtasks = listEpicWorkflowTasks(allTasks, task.id);
+    }
+    else {
+        workflowSubtasks = listSubtasks(allTasks, task.id);
+    }
+    const subtasks = workflowSubtasks.map((entry) => mapSubtaskSummary(entry, stageTitles, allTasks));
+    let parent = null;
+    if (task.parentId !== null) {
+        const found = allTasks.find((entry) => entry.id === task.parentId);
+        if (found)
+            parent = found;
+    }
+    let parentPayload = null;
+    if (parent !== null) {
+        parentPayload = { taskId: parent.id, title: parent.title, stageId: parent.stageId };
+    }
+    let workStatusPayload = null;
+    if (task.parentId !== null) {
+        workStatusPayload = resolveWorkStatus(task);
+    }
+    let workStatusLabelPayload = null;
+    if (task.parentId !== null) {
+        workStatusLabelPayload = workStatusLabel(resolveWorkStatus(task));
+    }
+    let workflowState = null;
+    if (task.parentId === null) {
+        workflowState = listWorkflowStateSummaries(task.id).map((node) => Object.assign({}, node, { workStatusLabel: workStatusLabel(node.workStatus) }));
+    }
+    return {
+        taskId: task.id,
+        title: task.title,
+        request: canonicalDescription(task),
+        description: canonicalDescription(task),
+        priority: task.priority,
+        labels: task.labels,
+        assignee: task.assignee,
+        parentId: task.parentId,
+        parent: parentPayload,
+        subtasks,
+        stageId: task.stageId,
+        stage,
+        workStatus: workStatusPayload,
+        workStatusLabel: workStatusLabelPayload,
+        isEpic: task.parentId === null,
+        status: consumerStatus(task),
+        createdAt: task.createdAt,
+        updatedAt: task.updatedAt,
+        createdBy: task.createdBy,
+        projectId: task.projectId,
+        projectName: task.projectName,
+        claimedBy: task.claimedBy,
+        events: task.events,
+        comments: mapComments(task),
+        libraryLinks: listTaskLibraryLinks(task.id),
+        workflowState,
+    };
+}
+function parseActivityTime(item) {
+    let raw = null;
+    if (item.activityAt !== null) {
+        raw = item.activityAt;
+    }
+    else if (item.createdAt !== null) {
+        raw = item.createdAt;
+    }
+    if (!raw)
+        return NaN;
+    return Date.parse(raw);
+}
+function sortInboxByActivity(items) {
+    return items.slice().sort((a, b) => {
+        const aTime = parseActivityTime(a);
+        const bTime = parseActivityTime(b);
+        if (!Number.isNaN(aTime) && !Number.isNaN(bTime) && aTime !== bTime) {
+            return bTime - aTime;
+        }
+        return b.taskId - a.taskId;
+    });
+}
+export function buildInboxItems(query) {
+    const bridgeTasks = listBridgeTasks();
+    const stageTitles = new Map();
+    for (const task of bridgeTasks) {
+        if (stageTitles.has(task.projectId))
+            continue;
+        const lookup = getStageTitleLookup(task.projectId);
+        for (const [stageId, title] of lookup.entries()) {
+            stageTitles.set(`${task.projectId}:${stageId}`, title);
+        }
+        stageTitles.set(task.projectId, "loaded");
+    }
+    let items = bridgeTasks.map((task) => {
+        let activityAt = task.createdAt;
+        if (task.updatedAt) {
+            activityAt = task.updatedAt;
+        }
+        else if (task.claimedAt !== null) {
+            activityAt = task.claimedAt;
+        }
+        const stageTitle = resolveStageTitle(task.stageId, task.projectId, stageTitles);
+        return {
+            taskId: task.id,
+            title: task.title,
+            preview: previewForTask(task),
+            status: consumerStatus(task),
+            activityAt,
+            updatedAt: activityAt,
+            createdAt: task.createdAt,
+            done: isDoneStage(task.stageId),
+            parentId: task.parentId,
+            projectId: task.projectId,
+            projectName: task.projectName,
+            createdBy: task.createdBy,
+            claimedBy: task.claimedBy,
+            assignee: task.assignee,
+            stageId: task.stageId,
+            stageTitle,
+        };
+    });
+    if (query.projectId !== null) {
+        items = items.filter((item) => item.projectId === query.projectId);
+    }
+    if (query.commentsOnly) {
+        items = items.filter((item) => item.status === "ready");
+    }
+    if (query.epicsOnly) {
+        items = items.filter((item) => item.parentId === null);
+    }
+    items = sortInboxByActivity(items);
+    if (query.cursor !== null) {
+        const decoded = decodeInboxCursor(query.cursor);
+        if (!decoded)
+            throw new AppError("Invalid cursor", 400);
+        const cursorTime = Date.parse(decoded.activityAt);
+        items = items.filter((item) => inboxItemBeforeCursor(item, cursorTime, decoded.taskId, parseActivityTime));
+    }
+    const slice = items.slice(0, query.limit + 1);
+    const hasMore = slice.length > query.limit;
+    let pageItems = slice;
+    if (hasMore) {
+        pageItems = slice.slice(0, query.limit);
+    }
+    const lastItem = pageItems[pageItems.length - 1];
+    let nextCursor = null;
+    if (hasMore && lastItem) {
+        nextCursor = encodeInboxCursor(lastItem);
+    }
+    return {
+        items: pageItems,
+        limit: query.limit,
+        nextCursor,
+        hasMore,
+    };
+}

package/apps/backend/dist/middleware/auth.js

@@ -0,0 +1,29 @@
+import { AppError } from "../errors/app-error.js";
+import { listUserRows } from "../db/users-db.js";
+export function resolveAuthUser(request) {
+    const authHeader = request.headers["authorization"];
+    let token = "";
+    if (String(authHeader) === authHeader && authHeader.startsWith("Bearer ")) {
+        token = authHeader.slice(7);
+    }
+    if (token === "") {
+        throw new AppError("Unauthorized", 401);
+    }
+    const rows = listUserRows({ id: "", email: "", token });
+    if (rows.length === 0) {
+        throw new AppError("Unauthorized", 401);
+    }
+    const row = rows[0];
+    if (!row)
+        throw new AppError("Unauthorized", 401);
+    return row;
+}
+export function assertAuth(request) {
+    const row = resolveAuthUser(request);
+    if (row.must_change_password === 1) {
+        throw new AppError("Password change required", 403, {
+            code: "PASSWORD_CHANGE_REQUIRED",
+        });
+    }
+    return row;
+}