@dbos-inc/dbos-sdk 3.6.5-preview → 3.6.8-preview

package/dist/src/adminserver.js

@@ -22,15 +22,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DBOSAdminServer = exports.WorkflowQueuesMetadataUrl = exports.DeactivateUrl = exports.PerfUrl = exports.HealthUrl = exports.WorkflowRecoveryUrl = exports.WorkflowUUIDHeader = void 0;
-const koa_1 = __importDefault(require("koa"));
-const router_1 = __importDefault(require("@koa/router"));
-const bodyparser_1 = require("@koa/bodyparser");
-const cors_1 = __importDefault(require("@koa/cors"));
+const http = __importStar(require("http"));
+const url = __importStar(require("url"));
 const error_1 = require("./error");
 const net = __importStar(require("net"));
 const perf_hooks_1 = require("perf_hooks");
@@ -45,46 +40,131 @@ exports.HealthUrl = '/dbos-healthz';
 exports.PerfUrl = '/dbos-perf';
 exports.DeactivateUrl = '/deactivate';
 exports.WorkflowQueuesMetadataUrl = '/dbos-workflow-queues-metadata';
-class DBOSAdminServer {
-    dbosExec;
-    adminApp;
-    logger;
-    static nRegisteredEndpoints = 0;
-    static instance = undefined;
-    /**
-     * Create a Koa app.
-     * @param dbosExec User pass in an DBOS workflow executor instance.
-     * TODO: maybe call dbosExec.init() somewhere in this class?
-     */
-    constructor(dbosExec) {
-        this.dbosExec = dbosExec;
-        this.logger = dbosExec.logger;
-        this.adminApp = DBOSAdminServer.setupAdminApp(this.dbosExec);
-        DBOSAdminServer.instance = this;
+// Helper to parse JSON body
+async function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += String(chunk);
+        });
+        req.on('end', () => {
+            try {
+                resolve(body ? JSON.parse(body) : {});
+            }
+            catch (e) {
+                reject(new Error('Invalid JSON'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+// Helper to send JSON response
+function sendJson(res, statusCode, data) {
+    res.writeHead(statusCode, {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+    });
+    res.end(JSON.stringify(data));
+}
+// Helper to send text response
+function sendText(res, statusCode, text) {
+    res.writeHead(statusCode, {
+        'Content-Type': 'text/plain',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+    });
+    res.end(text);
+}
+// Helper to send no content response
+function sendNoContent(res) {
+    res.writeHead(204, {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+    });
+    res.end();
+}
+// Helper to extract path params
+function matchPath(pattern, pathname) {
+    const patternParts = pattern.split('/');
+    const pathParts = pathname.split('/');
+    if (patternParts.length !== pathParts.length)
+        return null;
+    const params = {};
+    for (let i = 0; i < patternParts.length; i++) {
+        const patternPart = patternParts[i];
+        const pathPart = pathParts[i];
+        if (patternPart.startsWith(':')) {
+            const paramName = patternPart.substring(1);
+            params[paramName] = pathPart;
+        }
+        else if (patternPart !== pathPart) {
+            return null;
+        }
     }
+    return params;
+}
+class DBOSAdminServer {
     static setupAdminApp(dbosExec) {
-        const adminRouter = new router_1.default();
-        const adminApp = new koa_1.default();
-        adminApp.use((0, bodyparser_1.bodyParser)());
-        adminApp.use((0, cors_1.default)());
+        const routes = [];
         // Register HTTP endpoints.
-        DBOSAdminServer.registerHealthEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerRecoveryEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerPerfEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerDeactivateEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerCancelWorkflowEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerResumeWorkflowEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerRestartWorkflowEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerQueueMetadataEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerListWorkflowStepsEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerListWorkflowsEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerListQueuedWorkflowsEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerGetWorkflowEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerForkWorkflowEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerGarbageCollectEndpoint(dbosExec, adminRouter);
-        DBOSAdminServer.registerGlobalTimeoutEndpoint(dbosExec, adminRouter);
-        adminApp.use(adminRouter.routes()).use(adminRouter.allowedMethods());
-        return adminApp;
+        DBOSAdminServer.registerHealthEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerRecoveryEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerPerfEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerDeactivateEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerCancelWorkflowEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerResumeWorkflowEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerRestartWorkflowEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerQueueMetadataEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerListWorkflowStepsEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerListWorkflowsEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerListQueuedWorkflowsEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerGetWorkflowEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerForkWorkflowEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerGarbageCollectEndpoint(dbosExec, routes);
+        DBOSAdminServer.registerGlobalTimeoutEndpoint(dbosExec, routes);
+        // Create the HTTP server
+        const server = http.createServer(async (req, res) => {
+            // Handle CORS preflight requests
+            if (req.method === 'OPTIONS') {
+                res.writeHead(200, {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                    'Access-Control-Allow-Headers': 'Content-Type',
+                    'Access-Control-Max-Age': '86400',
+                });
+                res.end();
+                return;
+            }
+            const parsedUrl = url.parse(req.url || '', true);
+            const pathname = parsedUrl.pathname || '';
+            // Find matching route
+            let routeFound = false;
+            for (const route of routes) {
+                if (req.method === route.method) {
+                    const params = matchPath(route.path, pathname);
+                    if (params !== null) {
+                        routeFound = true;
+                        try {
+                            await route.handler(req, res, params);
+                        }
+                        catch (error) {
+                            dbosExec.logger.error(`Request handler error: ${String(error)}`);
+                            sendJson(res, 500, { error: 'Internal server error' });
+                        }
+                        break;
+                    }
+                }
+            }
+            if (!routeFound) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Not Found');
+            }
+        });
+        return server;
     }
     static async checkPortAvailabilityIPv4Ipv6(port, logger) {
         try {
@@ -132,321 +212,346 @@ class DBOSAdminServer {
     /**
      * Health check endpoint.
      */
-    static registerHealthEndpoint(dbosExec, router) {
-        // Handler function that parses request for recovery.
-        const healthHandler = async (koaCtxt, koaNext) => {
-            koaCtxt.body = 'healthy';
-            await koaNext();
-        };
-        router.get(exports.HealthUrl, healthHandler);
+    static registerHealthEndpoint(dbosExec, routes) {
+        routes.push({
+            method: 'GET',
+            path: exports.HealthUrl,
+            handler: async (req, res) => {
+                sendText(res, 200, 'healthy');
+                return Promise.resolve();
+            },
+        });
         dbosExec.logger.debug(`DBOS Server Registered Healthz GET ${exports.HealthUrl}`);
     }
     /**
      * Register workflow queue metadata endpoint.
      */
-    static registerQueueMetadataEndpoint(dbosExec, router) {
-        const queueMetadataHandler = async (koaCtxt, koaNext) => {
-            const queueDetailsArray = [];
-            wfqueue_1.wfQueueRunner.wfQueuesByName.forEach((q, qn) => {
-                queueDetailsArray.push({
-                    name: qn,
-                    concurrency: q.concurrency,
-                    workerConcurrency: q.workerConcurrency,
-                    rateLimit: q.rateLimit,
+    static registerQueueMetadataEndpoint(dbosExec, routes) {
+        routes.push({
+            method: 'GET',
+            path: exports.WorkflowQueuesMetadataUrl,
+            handler: async (req, res) => {
+                const queueDetailsArray = [];
+                wfqueue_1.wfQueueRunner.wfQueuesByName.forEach((q, qn) => {
+                    queueDetailsArray.push({
+                        name: qn,
+                        concurrency: q.concurrency,
+                        workerConcurrency: q.workerConcurrency,
+                        rateLimit: q.rateLimit,
+                    });
                 });
-            });
-            koaCtxt.body = queueDetailsArray;
-            await koaNext();
-        };
-        router.get(exports.WorkflowQueuesMetadataUrl, queueMetadataHandler);
+                sendJson(res, 200, queueDetailsArray);
+                return Promise.resolve();
+            },
+        });
         dbosExec.logger.debug(`DBOS Server Registered Queue Metadata GET ${exports.WorkflowQueuesMetadataUrl}`);
     }
     /**
      * Register workflow recovery endpoint.
      * Receives a list of executor IDs and returns a list of workflowUUIDs.
      */
-    static registerRecoveryEndpoint(dbosExec, router) {
-        // Handler function that parses request for recovery.
-        const recoveryHandler = async (koaCtxt, koaNext) => {
-            const executorIDs = koaCtxt.request.body;
-            dbosExec.logger.info('Recovering workflows for executors: ' + executorIDs.toString());
-            const recoverHandles = await dbosExec.recoverPendingWorkflows(executorIDs);
-            // Return a list of workflowUUIDs being recovered.
-            koaCtxt.body = await Promise.allSettled(recoverHandles.map((i) => i.workflowID)).then((results) => results.filter((i) => i.status === 'fulfilled').map((i) => i.value));
-            await koaNext();
-        };
-        router.post(exports.WorkflowRecoveryUrl, recoveryHandler);
+    static registerRecoveryEndpoint(dbosExec, routes) {
+        routes.push({
+            method: 'POST',
+            path: exports.WorkflowRecoveryUrl,
+            handler: async (req, res) => {
+                const executorIDs = (await parseJsonBody(req));
+                dbosExec.logger.info('Recovering workflows for executors: ' + executorIDs.toString());
+                const recoverHandles = await dbosExec.recoverPendingWorkflows(executorIDs);
+                // Return a list of workflowUUIDs being recovered.
+                const result = await Promise.allSettled(recoverHandles.map((i) => i.workflowID)).then((results) => results.filter((i) => i.status === 'fulfilled').map((i) => i.value));
+                sendJson(res, 200, result);
+            },
+        });
         dbosExec.logger.debug(`DBOS Server Registered Recovery POST ${exports.WorkflowRecoveryUrl}`);
     }
     /**
      * Register performance endpoint.
      * Returns information on VM performance since last call.
      */
-    static registerPerfEndpoint(dbosExec, router) {
-        let lastELU = perf_hooks_1.performance.eventLoopUtilization();
-        const perfHandler = async (koaCtxt, koaNext) => {
-            const currELU = perf_hooks_1.performance.eventLoopUtilization();
-            const elu = perf_hooks_1.performance.eventLoopUtilization(currELU, lastELU);
-            koaCtxt.body = elu;
-            lastELU = currELU;
-            await koaNext();
-        };
-        router.get(exports.PerfUrl, perfHandler);
+    static lastELU = perf_hooks_1.performance.eventLoopUtilization();
+    static registerPerfEndpoint(dbosExec, routes) {
+        routes.push({
+            method: 'GET',
+            path: exports.PerfUrl,
+            handler: async (req, res) => {
+                const currELU = perf_hooks_1.performance.eventLoopUtilization();
+                const elu = perf_hooks_1.performance.eventLoopUtilization(currELU, DBOSAdminServer.lastELU);
+                sendJson(res, 200, elu);
+                DBOSAdminServer.lastELU = currELU;
+                return Promise.resolve();
+            },
+        });
         dbosExec.logger.debug(`DBOS Server Registered Perf GET ${exports.PerfUrl}`);
     }
     /**
      * Register Deactivate endpoint.
      * Deactivate consumers so that they don't start new workflows.
-     *
      */
     static isDeactivated = false;
-    static registerDeactivateEndpoint(dbosExec, router) {
-        const deactivateHandler = async (koaCtxt, koaNext) => {
-            if (!DBOSAdminServer.isDeactivated) {
-                dbosExec.logger.info(`Deactivating DBOS executor ${utils_1.globalParams.executorID} with version ${utils_1.globalParams.appVersion}. This executor will complete existing workflows but will not create new workflows.`);
-                DBOSAdminServer.isDeactivated = true;
-            }
-            await dbosExec.deactivateEventReceivers(false);
-            koaCtxt.body = 'Deactivated';
-            await koaNext();
-        };
-        router.get(exports.DeactivateUrl, deactivateHandler);
+    static registerDeactivateEndpoint(dbosExec, routes) {
+        routes.push({
+            method: 'GET',
+            path: exports.DeactivateUrl,
+            handler: async (req, res) => {
+                if (!DBOSAdminServer.isDeactivated) {
+                    dbosExec.logger.info(`Deactivating DBOS executor ${utils_1.globalParams.executorID} with version ${utils_1.globalParams.appVersion}. This executor will complete existing workflows but will not create new workflows.`);
+                    DBOSAdminServer.isDeactivated = true;
+                }
+                await dbosExec.deactivateEventReceivers(false);
+                sendText(res, 200, 'Deactivated');
+            },
+        });
         dbosExec.logger.debug(`DBOS Server Registered Deactivate GET ${exports.DeactivateUrl}`);
     }
-    static registerGarbageCollectEndpoint(dbosExec, router) {
+    static registerGarbageCollectEndpoint(dbosExec, routes) {
         const url = '/dbos-garbage-collect';
-        const handler = async (koaCtxt) => {
-            const body = koaCtxt.request.body;
-            await dbosExec.systemDatabase.garbageCollect(body.cutoff_epoch_timestamp_ms, body.rows_threshold);
-            koaCtxt.status = 204;
-        };
-        router.post(url, handler);
+        routes.push({
+            method: 'POST',
+            path: url,
+            handler: async (req, res) => {
+                const body = (await parseJsonBody(req));
+                await dbosExec.systemDatabase.garbageCollect(body.cutoff_epoch_timestamp_ms, body.rows_threshold);
+                sendNoContent(res);
+            },
+        });
     }
-    static registerGlobalTimeoutEndpoint(dbosExec, router) {
+    static registerGlobalTimeoutEndpoint(dbosExec, routes) {
         const url = '/dbos-global-timeout';
-        const handler = async (koaCtxt) => {
-            const body = koaCtxt.request.body;
-            await (0, workflow_management_1.globalTimeout)(dbosExec.systemDatabase, body.cutoff_epoch_timestamp_ms);
-            koaCtxt.status = 204;
-        };
-        router.post(url, handler);
+        routes.push({
+            method: 'POST',
+            path: url,
+            handler: async (req, res) => {
+                const body = (await parseJsonBody(req));
+                await (0, workflow_management_1.globalTimeout)(dbosExec.systemDatabase, body.cutoff_epoch_timestamp_ms);
+                sendNoContent(res);
+            },
+        });
     }
     /**
-     *
      * Register Cancel Workflow endpoint.
      * Cancels a workflow by setting its status to CANCELLED.
      */
-    static registerCancelWorkflowEndpoint(dbosExec, router) {
+    static registerCancelWorkflowEndpoint(dbosExec, routes) {
         const workflowCancelUrl = '/workflows/:workflow_id/cancel';
-        const workflowCancelHandler = async (koaCtxt) => {
-            const workflowId = koaCtxt.params.workflow_id;
-            await dbosExec.cancelWorkflow(workflowId);
-            koaCtxt.status = 204;
-        };
-        router.post(workflowCancelUrl, workflowCancelHandler);
+        routes.push({
+            method: 'POST',
+            path: workflowCancelUrl,
+            handler: async (req, res, params) => {
+                const workflowId = params.workflow_id;
+                await dbosExec.cancelWorkflow(workflowId);
+                sendNoContent(res);
+            },
+        });
         dbosExec.logger.debug(`DBOS Server Registered Cancel Workflow POST ${workflowCancelUrl}`);
     }
     /**
-     *
      * Register Resume Workflow endpoint.
      * Resume a workflow.
      */
-    static registerResumeWorkflowEndpoint(dbosExec, router) {
+    static registerResumeWorkflowEndpoint(dbosExec, routes) {
         const workflowResumeUrl = '/workflows/:workflow_id/resume';
-        const workflowResumeHandler = async (koaCtxt) => {
-            const workflowId = koaCtxt.params.workflow_id;
-            dbosExec.logger.info(`Resuming workflow with ID: ${workflowId}`);
-            try {
-                await dbosExec.resumeWorkflow(workflowId);
-            }
-            catch (e) {
-                let errorMessage = '';
-                if (e instanceof error_1.DBOSError) {
-                    errorMessage = e.message;
+        routes.push({
+            method: 'POST',
+            path: workflowResumeUrl,
+            handler: async (req, res, params) => {
+                const workflowId = params.workflow_id;
+                dbosExec.logger.info(`Resuming workflow with ID: ${workflowId}`);
+                try {
+                    await dbosExec.resumeWorkflow(workflowId);
+                    sendNoContent(res);
                 }
-                else {
-                    errorMessage = `Unknown error`;
+                catch (e) {
+                    let errorMessage = '';
+                    if (e instanceof error_1.DBOSError) {
+                        errorMessage = e.message;
+                    }
+                    else {
+                        errorMessage = `Unknown error`;
+                    }
+                    dbosExec.logger.error(`Error resuming workflow ${workflowId}: ${errorMessage}`);
+                    sendJson(res, 500, {
+                        error: `Error resuming workflow ${workflowId}: ${errorMessage}`,
+                    });
                 }
-                dbosExec.logger.error(`Error resuming workflow ${workflowId}: ${errorMessage}`);
-                koaCtxt.status = 500;
-                koaCtxt.body = {
-                    error: `Error resuming workflow ${workflowId}: ${errorMessage}`,
-                };
-                return;
-            }
-            koaCtxt.status = 204;
-        };
-        router.post(workflowResumeUrl, workflowResumeHandler);
-        dbosExec.logger.debug(`DBOS Server Registered Cancel Workflow POST ${workflowResumeUrl}`);
+            },
+        });
+        dbosExec.logger.debug(`DBOS Server Registered Resume Workflow POST ${workflowResumeUrl}`);
     }
     /**
-     *
      * Register Restart Workflow endpoint.
      * Restart a workflow.
      */
-    static registerRestartWorkflowEndpoint(dbosExec, router) {
-        const workflowResumeUrl = '/workflows/:workflow_id/restart';
-        const workflowRestartHandler = async (koaCtxt) => {
-            const workflowId = koaCtxt.params.workflow_id;
-            dbosExec.logger.info(`Restarting workflow: ${workflowId} with a new id`);
-            const workflowID = await dbosExec.forkWorkflow(workflowId, 0);
-            koaCtxt.body = {
-                workflow_id: workflowID,
-            };
-            koaCtxt.status = 200;
-        };
-        router.post(workflowResumeUrl, workflowRestartHandler);
-        dbosExec.logger.debug(`DBOS Server Registered Cancel Workflow POST ${workflowResumeUrl}`);
+    static registerRestartWorkflowEndpoint(dbosExec, routes) {
+        const workflowRestartUrl = '/workflows/:workflow_id/restart';
+        routes.push({
+            method: 'POST',
+            path: workflowRestartUrl,
+            handler: async (req, res, params) => {
+                const workflowId = params.workflow_id;
+                dbosExec.logger.info(`Restarting workflow: ${workflowId} with a new id`);
+                const workflowID = await dbosExec.forkWorkflow(workflowId, 0);
+                sendJson(res, 200, {
+                    workflow_id: workflowID,
+                });
+            },
+        });
+        dbosExec.logger.debug(`DBOS Server Registered Restart Workflow POST ${workflowRestartUrl}`);
     }
     /**
-     *
      * Register Fork Workflow endpoint.
-     *
      */
-    static registerForkWorkflowEndpoint(dbosExec, router) {
-        const workflowResumeUrl = '/workflows/:workflow_id/fork';
-        const workflowForkHandler = async (koaCtxt) => {
-            const workflowId = koaCtxt.params.workflow_id;
-            const body = koaCtxt.request.body;
-            if (body.start_step === undefined) {
-                throw new error_1.DBOSDataValidationError('Missing start_step in request body');
-            }
-            dbosExec.logger.info(`Forking workflow: ${workflowId} from step ${body.start_step} with a new id`);
-            try {
-                const workflowID = await dbosExec.forkWorkflow(workflowId, body.start_step, {
-                    newWorkflowID: body.new_workflow_id,
-                    applicationVersion: body.application_version,
-                    timeoutMS: body.timeout_ms,
-                });
-                koaCtxt.body = {
-                    workflow_id: workflowID,
-                };
-            }
-            catch (e) {
-                let errorMessage = '';
-                if (e instanceof error_1.DBOSError) {
-                    errorMessage = e.message;
+    static registerForkWorkflowEndpoint(dbosExec, routes) {
+        const workflowForkUrl = '/workflows/:workflow_id/fork';
+        routes.push({
+            method: 'POST',
+            path: workflowForkUrl,
+            handler: async (req, res, params) => {
+                const workflowId = params.workflow_id;
+                const body = (await parseJsonBody(req));
+                if (body.start_step === undefined) {
+                    sendJson(res, 400, { error: 'Missing start_step in request body' });
+                    return;
                 }
-                else {
-                    errorMessage = `Unknown error`;
+                dbosExec.logger.info(`Forking workflow: ${workflowId} from step ${body.start_step} with a new id`);
+                try {
+                    const workflowID = await dbosExec.forkWorkflow(workflowId, body.start_step, {
+                        newWorkflowID: body.new_workflow_id,
+                        applicationVersion: body.application_version,
+                        timeoutMS: body.timeout_ms,
+                    });
+                    sendJson(res, 200, {
+                        workflow_id: workflowID,
+                    });
                 }
-                dbosExec.logger.error(`Error forking workflow ${workflowId}: ${errorMessage}`);
-                koaCtxt.status = 500;
-                koaCtxt.body = {
-                    error: `Error forking workflow ${workflowId}: ${errorMessage}`,
-                };
-                return;
-            }
-            dbosExec.logger.info(`Forked workflow: ${workflowId} with a new id`);
-            koaCtxt.status = 200;
-        };
-        router.post(workflowResumeUrl, workflowForkHandler);
-        dbosExec.logger.debug(`DBOS Server Registered Cancel Workflow POST ${workflowResumeUrl}`);
+                catch (e) {
+                    let errorMessage = '';
+                    if (e instanceof error_1.DBOSError) {
+                        errorMessage = e.message;
+                    }
+                    else {
+                        errorMessage = `Unknown error`;
+                    }
+                    dbosExec.logger.error(`Error forking workflow ${workflowId}: ${errorMessage}`);
+                    sendJson(res, 500, {
+                        error: `Error forking workflow ${workflowId}: ${errorMessage}`,
+                    });
+                }
+            },
+        });
+        dbosExec.logger.debug(`DBOS Server Registered Fork Workflow POST ${workflowForkUrl}`);
     }
     /**
-     *
      * Register List Workflow Steps endpoint.
      * List steps for a given workflow.
      */
-    static registerListWorkflowStepsEndpoint(dbosExec, router) {
+    static registerListWorkflowStepsEndpoint(dbosExec, routes) {
         const workflowStepsUrl = '/workflows/:workflow_id/steps';
-        const workflowStepsHandler = async (koaCtxt) => {
-            const workflowId = koaCtxt.params.workflow_id;
-            const steps = await dbosExec.listWorkflowSteps(workflowId);
-            koaCtxt.body = steps?.map((step) => ({
-                function_name: step.name,
-                function_id: step.functionID,
-                output: step.output ? utils_1.DBOSJSON.stringify(step.output) : undefined,
-                error: step.error ? utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(step.error)) : undefined,
-                child_workflow_id: step.childWorkflowID,
-            }));
-            koaCtxt.status = 200;
-        };
-        router.get(workflowStepsUrl, workflowStepsHandler);
+        routes.push({
+            method: 'GET',
+            path: workflowStepsUrl,
+            handler: async (req, res, params) => {
+                const workflowId = params.workflow_id;
+                const steps = await dbosExec.listWorkflowSteps(workflowId);
+                const result = steps?.map((step) => ({
+                    function_name: step.name,
+                    function_id: step.functionID,
+                    output: step.output ? utils_1.DBOSJSON.stringify(step.output) : undefined,
+                    error: step.error ? utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(step.error)) : undefined,
+                    child_workflow_id: step.childWorkflowID,
+                }));
+                sendJson(res, 200, result);
+            },
+        });
         dbosExec.logger.debug(`DBOS Server Registered List Workflow steps Get ${workflowStepsUrl}`);
     }
     /**
-     *
      * Register List Workflows endpoint.
      * List workflows with optional filtering via request body.
      */
-    static registerListWorkflowsEndpoint(dbosExec, router) {
+    static registerListWorkflowsEndpoint(dbosExec, routes) {
         const listWorkflowsUrl = '/workflows';
-        const listWorkflowsHandler = async (koaCtxt) => {
-            const body = koaCtxt.request.body;
-            // Map request body keys to GetWorkflowsInput properties
-            const input = {
-                workflowIDs: body.workflow_uuids,
-                workflowName: body.workflow_name,
-                authenticatedUser: body.authenticated_user,
-                startTime: body.start_time,
-                endTime: body.end_time,
-                status: body.status,
-                applicationVersion: body.application_version,
-                limit: body.limit,
-                offset: body.offset,
-                sortDesc: body.sort_desc,
-                workflow_id_prefix: body.workflow_id_prefix,
-                loadInput: body.load_input ?? false, // Default to false
-                loadOutput: body.load_output ?? false, // Default to false
-            };
-            const workflows = await dbosExec.listWorkflows(input);
-            // Map result to the underscore format.
-            koaCtxt.body = workflows.map((wf) => new protocol.WorkflowsOutput(wf));
-            koaCtxt.status = 200;
-        };
-        router.post(listWorkflowsUrl, listWorkflowsHandler);
+        routes.push({
+            method: 'POST',
+            path: listWorkflowsUrl,
+            handler: async (req, res) => {
+                const body = (await parseJsonBody(req));
+                // Map request body keys to GetWorkflowsInput properties
+                const input = {
+                    workflowIDs: body.workflow_uuids,
+                    workflowName: body.workflow_name,
+                    authenticatedUser: body.authenticated_user,
+                    startTime: body.start_time,
+                    endTime: body.end_time,
+                    status: body.status,
+                    applicationVersion: body.application_version,
+                    limit: body.limit,
+                    offset: body.offset,
+                    sortDesc: body.sort_desc,
+                    workflow_id_prefix: body.workflow_id_prefix,
+                    loadInput: body.load_input ?? false,
+                    loadOutput: body.load_output ?? false,
+                };
+                const workflows = await dbosExec.listWorkflows(input);
+                // Map result to the underscore format.
+                const result = workflows.map((wf) => new protocol.WorkflowsOutput(wf));
+                sendJson(res, 200, result);
+            },
+        });
         dbosExec.logger.debug(`DBOS Server Registered List Workflows POST ${listWorkflowsUrl}`);
     }
     /**
-     *
      * Register List Queued Workflows endpoint.
      * List queued workflows with optional filtering via request body.
      */
-    static registerListQueuedWorkflowsEndpoint(dbosExec, router) {
+    static registerListQueuedWorkflowsEndpoint(dbosExec, routes) {
         const listQueuedWorkflowsUrl = '/queues';
-        const listQueuedWorkflowsHandler = async (koaCtxt) => {
-            const body = koaCtxt.request.body;
-            // Map request body keys to GetQueuedWorkflowsInput properties
-            const input = {
-                workflowName: body.workflow_name,
-                startTime: body.start_time,
-                endTime: body.end_time,
-                status: body.status,
-                queueName: body.queue_name,
-                limit: body.limit,
-                offset: body.offset,
-                sortDesc: body.sort_desc,
-                loadInput: body.load_input ?? false, // Default to false
-            };
-            const workflows = await dbosExec.listQueuedWorkflows(input);
-            // Map result to the underscore format.
-            koaCtxt.body = workflows.map((wf) => new protocol.WorkflowsOutput(wf));
-            koaCtxt.status = 200;
-        };
-        router.post(listQueuedWorkflowsUrl, listQueuedWorkflowsHandler);
+        routes.push({
+            method: 'POST',
+            path: listQueuedWorkflowsUrl,
+            handler: async (req, res) => {
+                const body = (await parseJsonBody(req));
+                // Map request body keys to GetQueuedWorkflowsInput properties
+                const input = {
+                    workflowName: body.workflow_name,
+                    startTime: body.start_time,
+                    endTime: body.end_time,
+                    status: body.status,
+                    queueName: body.queue_name,
+                    limit: body.limit,
+                    offset: body.offset,
+                    sortDesc: body.sort_desc,
+                    loadInput: body.load_input ?? false,
+                };
+                const workflows = await dbosExec.listQueuedWorkflows(input);
+                // Map result to the underscore format.
+                const result = workflows.map((wf) => new protocol.WorkflowsOutput(wf));
+                sendJson(res, 200, result);
+            },
+        });
         dbosExec.logger.debug(`DBOS Server Registered List Queued Workflows POST ${listQueuedWorkflowsUrl}`);
     }
     /**
-     *
      * Register Get Workflow endpoint.
      * Get detailed information about a specific workflow by ID.
      */
-    static registerGetWorkflowEndpoint(dbosExec, router) {
+    static registerGetWorkflowEndpoint(dbosExec, routes) {
         const getWorkflowUrl = '/workflows/:workflow_id';
-        const getWorkflowHandler = async (koaCtxt) => {
-            const workflowId = koaCtxt.params.workflow_id;
-            const workflow = await dbosExec.getWorkflowStatus(workflowId);
-            if (workflow) {
-                koaCtxt.body = new protocol.WorkflowsOutput(workflow);
-                koaCtxt.status = 200;
-            }
-            else {
-                koaCtxt.status = 404;
-                koaCtxt.body = { error: `Workflow ${workflowId} not found` };
-            }
-        };
-        router.get(getWorkflowUrl, getWorkflowHandler);
+        routes.push({
+            method: 'GET',
+            path: getWorkflowUrl,
+            handler: async (req, res, params) => {
+                const workflowId = params.workflow_id;
+                const workflow = await dbosExec.getWorkflowStatus(workflowId);
+                if (workflow) {
+                    const result = new protocol.WorkflowsOutput(workflow);
+                    sendJson(res, 200, result);
+                }
+                else {
+                    sendJson(res, 404, { error: `Workflow ${workflowId} not found` });
+                }
+            },
+        });
         dbosExec.logger.debug(`DBOS Server Registered Get Workflow GET ${getWorkflowUrl}`);
     }
 }