ts-workflow-engine-lite 2.1.0

package/dist/src/api/routes/instances.js

@@ -0,0 +1,790 @@
+import express from "express";
+import { body, param, validationResult } from "express-validator";
+import { workflowDebugger } from "../../debug/WorkflowDebugger.js";
+import { searchInstances, } from "../../engine/InstanceSearch.js";
+import { searchAttributeManager, } from "../../engine/SearchAttributeManager.js";
+import { errorMessage, errorStack, Logger } from "../../utils/Logger.js";
+import { rbacMiddleware } from "../middleware/rbac.js";
+import { sendError, sendSuccess } from "../response.js";
+import { InstanceApplicationService } from "../services/InstanceApplicationService.js";
+import { getRequestEngine, getRequestStorage } from "../utils/requestContext.js";
+import { asyncHandler } from "../utils/routeHelper.js";
+const router = express.Router();
+function getService(req) {
+    const engine = getRequestEngine(req);
+    const storage = getRequestStorage(req) ?? null;
+    return new InstanceApplicationService(engine, storage);
+}
+function getEngine(req) {
+    return getRequestEngine(req);
+}
+function getStorage(req, engine) {
+    void engine;
+    return getRequestStorage(req);
+}
+function validateRequest(req, res) {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) {
+        sendError(res, 400, 400, errors.array()[0].msg);
+        return false;
+    }
+    return true;
+}
+function _getTotalNodes(workflow) {
+    const nodes = workflow?.nodes;
+    if (!nodes)
+        return 0;
+    if (Array.isArray(nodes))
+        return nodes.length;
+    if (typeof nodes === "object")
+        return Object.keys(nodes).length;
+    return 0;
+}
+router.post("/workflows/:id/dry-run", param("id").isString().notEmpty().withMessage("Workflow ID is required"), body("context")
+    .optional()
+    .isObject()
+    .withMessage("Context must be an object"), body("options")
+    .optional()
+    .isObject()
+    .withMessage("Options must be an object"), async (req, res) => {
+    if (!validateRequest(req, res)) {
+        return;
+    }
+    try {
+        const engine = getEngine(req);
+        const workflowId = req.params.id;
+        const result = await engine.dryRun(workflowId, req.body?.context ?? {}, req.body?.options ?? {});
+        return sendSuccess(res, 200, result, "Workflow dry run completed");
+    }
+    catch (error) {
+        Logger.error("api", "instances", `Error running dry run for ${req.params.id}: ${errorMessage(error)}`, errorStack(error));
+        return sendError(res, 500, 500, errorMessage(error) || "Failed to execute dry run");
+    }
+});
+function toEpochMs(value) {
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : 0;
+    }
+    if (typeof value === "string") {
+        const parsedDate = Date.parse(value);
+        if (!Number.isNaN(parsedDate)) {
+            return parsedDate;
+        }
+        const parsedNumber = Number(value);
+        if (Number.isFinite(parsedNumber)) {
+            return parsedNumber;
+        }
+    }
+    return 0;
+}
+async function loadInstance(engine, storage, instanceId) {
+    const maybeInstance = await Promise.resolve(engine.getInstance(instanceId));
+    if (maybeInstance) {
+        return maybeInstance;
+    }
+    if (storage?.loadInstance) {
+        const stored = await storage.loadInstance(instanceId);
+        return stored ?? undefined;
+    }
+    return undefined;
+}
+async function _loadAllInstances(engine, storage) {
+    if (storage) {
+        const ids = await storage.listInstances();
+        const instances = await Promise.all(ids.map((instanceId) => storage.loadInstance(instanceId)));
+        return instances.filter((inst) => Boolean(inst));
+    }
+    return engine
+        .listInstances()
+        .map((id) => engine.getInstance(id))
+        .filter((inst) => Boolean(inst));
+}
+async function _invokeInstanceLifecycleMethod(engine, methodName, instanceId) {
+    switch (methodName) {
+        case "cancelInstance":
+            if (typeof engine.cancelInstance !== "function") {
+                break;
+            }
+            return await engine.cancelInstance(instanceId);
+        case "pauseInstance":
+            if (typeof engine.pauseInstance !== "function") {
+                break;
+            }
+            return await engine.pauseInstance(instanceId);
+        case "resumeInstance":
+            if (typeof engine.resumeInstance !== "function") {
+                break;
+            }
+            return await engine.resumeInstance(instanceId);
+        default:
+            break;
+    }
+    throw new Error(`${methodName} is not supported by the current engine`);
+}
+router.get("/", asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const page = req.query.page
+        ? Number.parseInt(req.query.page, 10)
+        : 1;
+    const pageSize = req.query.pageSize
+        ? Number.parseInt(req.query.pageSize, 10)
+        : 50;
+    if (page < 1 || pageSize < 1 || pageSize > 100) {
+        res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message: "Invalid pagination parameters (page >= 1, 1 <= pageSize <= 100)",
+        });
+        return;
+    }
+    const result = await service.listInstances({
+        workflowId: req.query.workflowId,
+        status: req.query.status,
+        startTime: req.query.startTime
+            ? Number.parseInt(req.query.startTime, 10)
+            : undefined,
+        endTime: req.query.endTime
+            ? Number.parseInt(req.query.endTime, 10)
+            : undefined,
+        page,
+        pageSize,
+        sortBy: req.query.sortBy || "createdAt",
+        sortOrder: req.query.sortOrder || "desc",
+        parentId: req.query.parentId,
+    });
+    res.json({
+        success: true,
+        data: {
+            instances: result.instances,
+            pagination: {
+                page: result.page,
+                pageSize: result.pageSize,
+                totalCount: result.total,
+                totalPages: Math.ceil(result.total / result.pageSize),
+            },
+        },
+        message: "Instances retrieved",
+    });
+}));
+router.get("/search", asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const workflowId = req.query.workflowId;
+    const status = typeof req.query.status === "string" && req.query.status.length > 0
+        ? req.query.status.split(",").map((s) => s.trim())
+        : undefined;
+    let attributes;
+    if (typeof req.query.attributes === "string") {
+        try {
+            attributes = JSON.parse(req.query.attributes);
+        }
+        catch {
+            res.status(400).json({
+                success: false,
+                error: "VALIDATION_ERROR",
+                message: "attributes must be a valid JSON object",
+            });
+            return;
+        }
+    }
+    const offset = req.query.offset
+        ? Number.parseInt(req.query.offset, 10)
+        : undefined;
+    const limit = req.query.limit
+        ? Number.parseInt(req.query.limit, 10)
+        : undefined;
+    const instanceIds = searchAttributeManager.query({
+        workflowId,
+        status,
+        attributes,
+        offset,
+        limit,
+    });
+    const instances = await Promise.all(instanceIds.map((id) => service.getInstance(id).catch(() => null)));
+    const results = instances
+        .filter((inst) => Boolean(inst))
+        .map((inst) => {
+        if (!inst)
+            return null;
+        return {
+            id: inst.instanceId,
+            workflowId: inst.workflowId,
+            status: inst.status,
+            createdAt: toEpochMs(inst.createdAt),
+            updatedAt: toEpochMs(inst.updatedAt),
+            currentNode: inst.currentNodes?.[0],
+            searchAttributes: inst.searchAttributes,
+        };
+    })
+        .filter(Boolean);
+    res.json({
+        success: true,
+        data: { instances: results, total: instanceIds.length },
+        message: "Instances retrieved",
+    });
+}));
+router.post("/search", asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const query = (req.body ?? {});
+    if (query.filters !== undefined && !Array.isArray(query.filters)) {
+        res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message: "filters must be an array",
+        });
+        return;
+    }
+    const storage = getRequestStorage(req);
+    let allInstances = [];
+    if (storage && typeof storage.listInstances === "function") {
+        const ids = await storage.listInstances();
+        allInstances = (await Promise.all(ids.map((id) => storage.loadInstance(id)))).filter((inst) => Boolean(inst));
+    }
+    else {
+        const engine = getRequestEngine(req);
+        const rawIds = await engine.listInstances();
+        const ids = Array.isArray(rawIds) ? rawIds : [];
+        allInstances = (await Promise.all(ids.map(async (id) => {
+            try {
+                return await service.loadRawInstance(id);
+            }
+            catch {
+                return null;
+            }
+        }))).filter((inst) => Boolean(inst));
+    }
+    let result;
+    try {
+        result = searchInstances(allInstances, query);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? errorMessage(error) : "Invalid search query";
+        res
+            .status(400)
+            .json({ success: false, error: "VALIDATION_ERROR", message: msg });
+        return;
+    }
+    res.json({
+        success: true,
+        data: {
+            instances: result.instances.map((inst) => ({
+                instanceId: inst.instanceId,
+                workflowId: inst.workflowId,
+                status: inst.status,
+                createdAt: toEpochMs(inst.createdAt),
+                updatedAt: toEpochMs(inst.updatedAt),
+                currentNodes: inst.currentNodes,
+                searchAttributes: inst.searchAttributes,
+            })),
+            pagination: result.pagination,
+            aggregations: result.aggregations,
+        },
+        message: "Instances retrieved",
+    });
+}));
+router.post("/batch/retry", asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const ids = req.body?.ids;
+    if (!Array.isArray(ids) || ids.length === 0) {
+        res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message: "Body must contain a non-empty ids array",
+        });
+        return;
+    }
+    const batchMaxSize = Number.parseInt(process.env.BATCH_MAX_SIZE || "100", 10);
+    if (ids.length > batchMaxSize) {
+        res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message: `Batch size exceeds limit (${batchMaxSize})`,
+        });
+        return;
+    }
+    const results = [];
+    const newInstanceIds = [];
+    const engine = getRequestEngine(req);
+    for (const rawId of ids) {
+        const id = String(rawId);
+        try {
+            const instance = await service.getInstance(id);
+            if (!["failed", "cancelled"].includes(instance.status)) {
+                results.push({
+                    id,
+                    ok: false,
+                    error: `Cannot retry instance with status '${instance.status}'`,
+                });
+                continue;
+            }
+            const newInstanceId = await engine.start(instance.workflowId, (instance.context ?? {}));
+            newInstanceIds.push(newInstanceId);
+            results.push({ id, ok: true, newInstanceId });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? errorMessage(error) : String(error);
+            results.push({ id, ok: false, error: msg });
+        }
+    }
+    const succeeded = results.filter((r) => r.ok).length;
+    res.json({
+        success: true,
+        data: {
+            retried: succeeded,
+            failed: results.length - succeeded,
+            newInstanceIds,
+            results,
+        },
+        message: "Batch retry completed",
+    });
+}));
+router.post("/batch/delete", rbacMiddleware({ resource: "instance", action: "delete" }), asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const ids = req.body?.ids;
+    const confirm = req.body?.confirm;
+    if (!Array.isArray(ids) || ids.length === 0) {
+        res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message: "Body must contain a non-empty ids array",
+        });
+        return;
+    }
+    if (confirm !== true) {
+        res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message: "Batch delete requires { confirm: true } to prevent accidental deletion",
+        });
+        return;
+    }
+    const batchMaxSize = Number.parseInt(process.env.BATCH_MAX_SIZE || "100", 10);
+    if (ids.length > batchMaxSize) {
+        res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message: `Batch size exceeds limit (${batchMaxSize})`,
+        });
+        return;
+    }
+    const results = [];
+    const TERMINAL = new Set(["completed", "failed", "cancelled"]);
+    for (const rawId of ids) {
+        const id = String(rawId);
+        try {
+            const instance = await service.getInstance(id);
+            if (!TERMINAL.has(instance.status)) {
+                results.push({
+                    id,
+                    ok: false,
+                    error: `Cannot delete instance with status '${instance.status}'`,
+                });
+                continue;
+            }
+            await service.deleteInstance(id);
+            results.push({ id, ok: true });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? errorMessage(error) : String(error);
+            results.push({ id, ok: false, error: msg });
+        }
+    }
+    const succeeded = results.filter((r) => r.ok).length;
+    res.json({
+        success: true,
+        data: { deleted: succeeded, failed: results.length - succeeded, results },
+        message: "Batch delete completed",
+    });
+}));
+const _BATCH_OPERATIONS = {
+    cancel: "cancelInstance",
+    pause: "pauseInstance",
+    resume: "resumeInstance",
+};
+router.post("/batch/:operation", asyncHandler(async (req, res) => {
+    const operation = req.params.operation;
+    const engine = getRequestEngine(req);
+    const BATCH_METHODS = {
+        cancel: "cancelInstance",
+        pause: "pauseInstance",
+        resume: "resumeInstance",
+    };
+    const methodName = BATCH_METHODS[operation];
+    if (!methodName) {
+        res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message: `Unknown batch operation: ${operation}. Supported: ${Object.keys(BATCH_METHODS).join(", ")}`,
+        });
+        return;
+    }
+    const ids = req.body?.ids;
+    if (!Array.isArray(ids) || ids.length === 0) {
+        res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message: "Body must contain a non-empty ids array",
+        });
+        return;
+    }
+    const batchMaxSize = Number.parseInt(process.env.BATCH_MAX_SIZE || "100", 10);
+    if (ids.length > batchMaxSize) {
+        res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message: `Batch size exceeds limit (${batchMaxSize})`,
+        });
+        return;
+    }
+    const results = [];
+    for (const rawId of ids) {
+        const id = String(rawId);
+        try {
+            const fn = engine[methodName];
+            if (typeof fn !== "function") {
+                results.push({
+                    id,
+                    ok: false,
+                    error: `Method ${methodName} not supported`,
+                });
+                continue;
+            }
+            const success = await fn.call(engine, id);
+            results.push(success
+                ? { id, ok: true }
+                : { id, ok: false, error: "Instance not found or not eligible" });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? errorMessage(error) : String(error);
+            results.push({ id, ok: false, error: msg });
+        }
+    }
+    const succeeded = results.filter((r) => r.ok).length;
+    res.json({
+        success: true,
+        data: { succeeded, failed: results.length - succeeded, results },
+        message: `Batch ${operation} completed`,
+    });
+}));
+router.get("/:id", param("id").isString().notEmpty().withMessage("Instance ID is required"), asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const instance = await service.getInstance(req.params.id);
+    res.json({
+        success: true,
+        data: instance,
+        message: "Instance retrieved",
+    });
+}));
+router.get("/:id/history", param("id").isString().notEmpty().withMessage("Instance ID is required"), async (req, res) => {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) {
+        return sendError(res, 400, 400, errors.array()[0].msg);
+    }
+    try {
+        const engine = getEngine(req);
+        const storage = getStorage(req, engine);
+        const instanceId = req.params.id;
+        const instance = await loadInstance(engine, storage, instanceId);
+        if (!instance) {
+            return sendError(res, 404, 404, `Instance with ID ${instanceId} not found`);
+        }
+        const executionHistory = instance.history
+            .sort((a, b) => toEpochMs(a.timestamp) - toEpochMs(b.timestamp))
+            .map((log) => ({
+            nodeId: log.nodeId,
+            timestamp: toEpochMs(log.timestamp),
+            status: log.status,
+            duration: log.duration,
+            data: log.data,
+            error: log.error,
+            stack: log.stack,
+        }));
+        return sendSuccess(res, 200, {
+            instanceId,
+            workflowId: instance.workflowId,
+            history: executionHistory,
+            totalSteps: executionHistory.length,
+        }, "Instance history retrieved");
+    }
+    catch (error) {
+        Logger.error("api", "instances", `Error getting instance history ${req.params.id}: ${errorMessage(error)}`, errorStack(error));
+        return sendError(res, 500, 500, errorMessage(error) || "Failed to retrieve instance history");
+    }
+});
+router.post("/:id/debug/attach", param("id").isString().notEmpty().withMessage("Instance ID is required"), (req, res) => {
+    if (!validateRequest(req, res)) {
+        return;
+    }
+    const instanceId = req.params.id;
+    workflowDebugger.attach(instanceId);
+    return sendSuccess(res, 200, workflowDebugger.getSnapshot(), `Debugger attached to instance ${instanceId}`);
+});
+router.post("/:id/debug/detach", (req, res) => {
+    const instanceId = req.params.id;
+    workflowDebugger.detach();
+    return sendSuccess(res, 200, { instanceId }, `Debugger detached from instance ${instanceId}`);
+});
+router.get("/:id/debug/snapshot", (_req, res) => {
+    return sendSuccess(res, 200, workflowDebugger.getSnapshot(), "Debugger snapshot retrieved");
+});
+router.post("/:id/debug/breakpoints", param("id").isString().notEmpty().withMessage("Instance ID is required"), body("nodeId").isString().notEmpty().withMessage("nodeId is required"), body("condition")
+    .optional()
+    .isString()
+    .withMessage("condition must be a string"), (req, res) => {
+    if (!validateRequest(req, res)) {
+        return;
+    }
+    const instanceId = req.params.id;
+    if (workflowDebugger.getSnapshot().instanceId !== instanceId) {
+        workflowDebugger.attach(instanceId);
+    }
+    const breakpoint = workflowDebugger.addBreakpoint(req.body.nodeId, req.body.condition);
+    return sendSuccess(res, 201, breakpoint, "Breakpoint added");
+});
+router.delete("/:id/debug/breakpoints/:breakpointId", param("breakpointId")
+    .isString()
+    .notEmpty()
+    .withMessage("breakpointId is required"), (req, res) => {
+    if (!validateRequest(req, res)) {
+        return;
+    }
+    const removed = workflowDebugger.removeBreakpoint(req.params.breakpointId);
+    return sendSuccess(res, removed ? 200 : 404, { removed }, removed ? "Breakpoint removed" : "Breakpoint not found");
+});
+router.patch("/:id/debug/breakpoints/:breakpointId", param("breakpointId")
+    .isString()
+    .notEmpty()
+    .withMessage("breakpointId is required"), body("enabled")
+    .optional()
+    .isBoolean()
+    .withMessage("enabled must be a boolean"), (req, res) => {
+    if (!validateRequest(req, res)) {
+        return;
+    }
+    const breakpoint = workflowDebugger.toggleBreakpoint(req.params.breakpointId, req.body.enabled);
+    if (!breakpoint) {
+        return sendError(res, 404, 404, "Breakpoint not found");
+    }
+    return sendSuccess(res, 200, breakpoint, "Breakpoint updated");
+});
+router.post("/:id/debug/resume", (_req, res) => {
+    workflowDebugger.resume();
+    return sendSuccess(res, 200, workflowDebugger.getSnapshot(), "Debugger resumed");
+});
+router.post("/:id/debug/step", (_req, res) => {
+    void workflowDebugger.step();
+    return sendSuccess(res, 200, workflowDebugger.getSnapshot(), "Debugger step requested");
+});
+router.post("/:id/signal", param("id").isString().notEmpty().withMessage("Instance ID is required"), body("name").isString().notEmpty().withMessage("Signal name is required"), body("payload").optional(), asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const result = await service.signalInstance(req.params.id, req.body.name, req.body.payload);
+    res.status(202).json({
+        success: true,
+        data: result,
+        message: `Signal ${req.body.name} sent to instance ${req.params.id}`,
+    });
+}));
+router.post("/:id/query", param("id").isString().notEmpty().withMessage("Instance ID is required"), body("name").isString().notEmpty().withMessage("Query name is required"), body("payload").optional(), asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const result = await service.queryInstance(req.params.id, req.body.name, req.body.payload);
+    res.json({
+        success: true,
+        data: result,
+        message: `Query ${req.body.name} completed for instance ${req.params.id}`,
+    });
+}));
+router.post("/:id/update", param("id").isString().notEmpty().withMessage("Instance ID is required"), body("name").isString().notEmpty().withMessage("Update name is required"), body("payload").optional(), body("correlationId").optional().isString(), asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const result = await service.updateInstance(req.params.id, req.body.name, req.body.payload, req.body.correlationId);
+    res.json({
+        success: true,
+        data: result,
+        message: `Update ${req.body.name} completed for instance ${req.params.id}`,
+    });
+}));
+router.post("/:id/pause", param("id").isString().notEmpty().withMessage("Instance ID is required"), asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const result = await service.pauseInstance(req.params.id);
+    res.json({
+        success: true,
+        data: { instanceId: result.instanceId },
+        message: `Instance ${req.params.id} paused successfully`,
+    });
+}));
+router.post("/:id/resume", param("id").isString().notEmpty().withMessage("Instance ID is required"), asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const result = await service.resumeInstance(req.params.id);
+    res.json({
+        success: true,
+        data: { instanceId: result.instanceId },
+        message: `Instance ${req.params.id} resumed successfully`,
+    });
+}));
+router.post("/:id/cancel", param("id").isString().notEmpty().withMessage("Instance ID is required"), asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const result = await service.cancelInstance(req.params.id);
+    res.json({
+        success: true,
+        data: { instanceId: result.instanceId },
+        message: `Instance ${req.params.id} cancelled successfully`,
+    });
+}));
+router.post("/:id/terminate", param("id").isString().notEmpty().withMessage("Instance ID is required"), asyncHandler(async (req, res) => {
+    const service = getService(req);
+    const result = await service.terminateInstance(req.params.id);
+    res.json({
+        success: true,
+        data: { instanceId: result.instanceId },
+        message: result.success
+            ? `Instance ${req.params.id} terminated successfully`
+            : `Instance ${req.params.id} was already in a terminal state`,
+    });
+}));
+router.post("/:id/nodes/:nodeId/retry", param("id").isString().notEmpty().withMessage("Instance ID is required"), param("nodeId").isString().notEmpty().withMessage("Node ID is required"), body("preserveInput")
+    .optional()
+    .isBoolean()
+    .withMessage("preserveInput must be a boolean"), body("maxRetries")
+    .optional()
+    .isInt({ min: 1 })
+    .withMessage("maxRetries must be a positive integer"), async (req, res) => {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) {
+        return sendError(res, 400, 400, errors.array()[0].msg);
+    }
+    try {
+        const engine = getEngine(req);
+        const instanceId = req.params.id;
+        const nodeId = req.params.nodeId;
+        await engine.retryNode(instanceId, nodeId);
+        return sendSuccess(res, 200, {
+            instanceId,
+            nodeId,
+        }, `Node ${nodeId} in instance ${instanceId} retried successfully`);
+    }
+    catch (error) {
+        Logger.error("api", "instances", `Error retrying node ${req.params.nodeId} in instance ${req.params.id}: ${errorMessage(error)}`, errorStack(error));
+        const statusCode = errorMessage(error)?.includes("not in a failed state") ||
+            errorMessage(error)?.includes("not found")
+            ? 400
+            : 500;
+        return sendError(res, statusCode, statusCode, errorMessage(error) || "Failed to retry node");
+    }
+});
+router.post("/:id/nodes/:nodeId/skip", param("id").isString().notEmpty().withMessage("Instance ID is required"), param("nodeId").isString().notEmpty().withMessage("Node ID is required"), body("defaultOutput").optional(), async (req, res) => {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) {
+        return sendError(res, 400, 400, errors.array()[0].msg);
+    }
+    try {
+        const engine = getEngine(req);
+        const instanceId = req.params.id;
+        const nodeId = req.params.nodeId;
+        const defaultOutput = req.body.defaultOutput;
+        await engine.skipNode(instanceId, nodeId, defaultOutput);
+        return sendSuccess(res, 200, {
+            instanceId,
+            nodeId,
+            defaultOutput,
+        }, `Node ${nodeId} in instance ${instanceId} skipped successfully`);
+    }
+    catch (error) {
+        Logger.error("api", "instances", `Error skipping node ${req.params.nodeId} in instance ${req.params.id}: ${errorMessage(error)}`, errorStack(error));
+        const statusCode = errorMessage(error)?.includes("already completed") ||
+            errorMessage(error)?.includes("not found")
+            ? 400
+            : 500;
+        return sendError(res, statusCode, statusCode, errorMessage(error) || "Failed to skip node");
+    }
+});
+router.post("/:id/compensate", param("id").isString().notEmpty().withMessage("Instance ID is required"), body("reason").optional().isString().withMessage("reason must be a string"), body("fromNode")
+    .optional()
+    .isString()
+    .withMessage("fromNode must be a string"), async (req, res) => {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) {
+        return sendError(res, 400, 400, errors.array()[0].msg);
+    }
+    try {
+        const engine = getEngine(req);
+        const instanceId = req.params.id;
+        const reason = req.body.reason;
+        await engine.compensate(instanceId, reason);
+        return sendSuccess(res, 200, {
+            instanceId,
+            reason,
+        }, `Compensation triggered for instance ${instanceId}`);
+    }
+    catch (error) {
+        Logger.error("api", "instances", `Error triggering compensation for instance ${req.params.id}: ${errorMessage(error)}`, errorStack(error));
+        const statusCode = errorMessage(error)?.includes("not found") ? 400 : 500;
+        return sendError(res, statusCode, statusCode, errorMessage(error) || "Failed to trigger compensation");
+    }
+});
+router.get("/:id/nodes/:nodeId/status", param("id").isString().notEmpty().withMessage("Instance ID is required"), param("nodeId").isString().notEmpty().withMessage("Node ID is required"), async (req, res) => {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) {
+        return sendError(res, 400, 400, errors.array()[0].msg);
+    }
+    try {
+        const engine = getEngine(req);
+        const storage = getStorage(req, engine);
+        const instanceId = req.params.id;
+        const nodeId = req.params.nodeId;
+        const instance = await loadInstance(engine, storage, instanceId);
+        if (!instance) {
+            return sendError(res, 404, 404, `Instance with ID ${instanceId} not found`);
+        }
+        const nodeHistory = instance.history.filter((log) => log.nodeId === nodeId);
+        if (nodeHistory.length === 0) {
+            return sendError(res, 404, 404, `Node ${nodeId} not found in instance ${instanceId}`);
+        }
+        const lastExecution = nodeHistory[nodeHistory.length - 1];
+        let status;
+        if (lastExecution.status === "success") {
+            status = "completed";
+        }
+        else if (lastExecution.status === "failed") {
+            status = "failed";
+        }
+        else if (lastExecution.status === "skipped") {
+            status = "skipped";
+        }
+        else if (instance.currentNodes?.includes(nodeId)) {
+            status = "running";
+        }
+        else {
+            status = "pending";
+        }
+        let duration;
+        if (lastExecution.duration !== undefined) {
+            duration = lastExecution.duration;
+        }
+        const retryCount = instance.retries?.[nodeId] || 0;
+        const output = instance.state?.nodes?.[nodeId]?.output;
+        const nodeStatus = {
+            nodeId,
+            status,
+            startTime: toEpochMs(lastExecution.timestamp),
+            endTime: toEpochMs(lastExecution.timestamp) + (duration || 0),
+            duration,
+            retryCount,
+            error: lastExecution.status === "failed"
+                ? {
+                    message: lastExecution.error || "Unknown error",
+                    stack: lastExecution.stack,
+                    timestamp: toEpochMs(lastExecution.timestamp),
+                }
+                : undefined,
+            output,
+        };
+        return sendSuccess(res, 200, nodeStatus, "Node status retrieved");
+    }
+    catch (error) {
+        Logger.error("api", "instances", `Error getting node status for ${req.params.nodeId} in instance ${req.params.id}: ${errorMessage(error)}`, errorStack(error));
+        return sendError(res, 500, 500, errorMessage(error) || "Failed to get node status");
+    }
+});
+export default router;
+//# sourceMappingURL=instances.js.map