@dbos-inc/dbos-sdk 2.9.9-preview → 2.9.18-preview

package/dist/src/dbos-executor.js

@@ -53,6 +53,7 @@ const wfqueue_1 = require("./wfqueue");
 const debugpoint_1 = require("./debugpoint");
 const scheduler_1 = require("./scheduler/scheduler");
 const crypto = __importStar(require("crypto"));
+const workflow_management_1 = require("./dbos-runtime/workflow_management");
 exports.dbosNull = {};
 function isDeprecatedDBOSConfig(config) {
     const isDeprecated = config.poolConfig !== undefined ||
@@ -114,8 +115,6 @@ class DBOSExecutor {
     stepInfoMap = new Map();
     procedureInfoMap = new Map();
     registeredOperations = [];
-    pendingWorkflowMap = new Map(); // Map from workflowUUID to workflow promise
-    workflowCancellationMap = new Map(); // Map from workflowUUID to its cancellation status.
     telemetryCollector;
     static defaultNotificationTimeoutSec = 60;
     debugMode;
@@ -398,10 +397,7 @@ class DBOSExecutor {
     }
     async destroy() {
         try {
-            if (this.pendingWorkflowMap.size > 0) {
-                this.logger.info('Waiting for pending workflows to finish.');
-                await Promise.allSettled(this.pendingWorkflowMap.values());
-            }
+            await this.systemDatabase.awaitRunningWorkflows();
             await this.systemDatabase.destroy();
             if (this.userDatabase) {
                 await this.userDatabase.destroy();
@@ -522,11 +518,11 @@ class DBOSExecutor {
     }
     // TODO: getProcedureInfoByNames??
     static reviveResultOrError(r, success) {
-        if (success === true || !r.err) {
-            return utils_1.DBOSJSON.parse(r.res ?? null);
+        if (success === true || !r.error) {
+            return utils_1.DBOSJSON.parse(r.output ?? null);
         }
         else {
-            throw (0, serialize_error_1.deserializeError)(utils_1.DBOSJSON.parse(r.err));
+            throw (0, serialize_error_1.deserializeError)(utils_1.DBOSJSON.parse(r.error));
         }
     }
     async workflow(wf, params, ...args) {
@@ -534,7 +530,7 @@ class DBOSExecutor {
     }
     // If callerUUID and functionID are set, it means the workflow is invoked from within a workflow.
     async internalWorkflow(wf, params, callerID, callerFunctionID, ...args) {
-        const workflowID = params.workflowUUID ? params.workflowUUID : this.#generateUUID();
+        const workflowID = params.workflowUUID ? params.workflowUUID : (0, node_crypto_1.randomUUID)();
         const presetID = params.workflowUUID ? true : false;
         const wInfo = this.getWorkflowInfo(wf);
         if (wInfo === undefined) {
@@ -569,34 +565,31 @@ class DBOSExecutor {
         // Synchronously set the workflow's status to PENDING and record workflow inputs.
         // We have to do it for all types of workflows because operation_outputs table has a foreign key constraint on workflow status table.
         if (this.isDebugging) {
-            // TODO: remove call to getWorkflowInputs after #871 is merged
             const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowID);
-            const wfInputs = await this.systemDatabase.getWorkflowInputs(workflowID);
-            if (!wfStatus || !wfInputs) {
+            if (!wfStatus) {
                 throw new error_1.DBOSDebuggerError(`Failed to find inputs for workflow UUID ${workflowID}`);
             }
             // Make sure we use the same input.
-            if (utils_1.DBOSJSON.stringify(args) !== utils_1.DBOSJSON.stringify(wfInputs)) {
-                throw new error_1.DBOSDebuggerError(`Detected different inputs for workflow UUID ${workflowID}.\n Received: ${utils_1.DBOSJSON.stringify(args)}\n Original: ${utils_1.DBOSJSON.stringify(wfInputs)}`);
+            if (utils_1.DBOSJSON.stringify(args) !== wfStatus.input) {
+                throw new error_1.DBOSDebuggerError(`Detected different inputs for workflow UUID ${workflowID}.\n Received: ${utils_1.DBOSJSON.stringify(args)}\n Original: ${wfStatus.input}`);
             }
             status = wfStatus.status;
         }
         else {
             // TODO: Make this transactional (and with the queue step below)
             if (callerFunctionID !== undefined && callerID !== undefined) {
-                const cr = await this.systemDatabase.getOperationResult(callerID, callerFunctionID);
-                if (cr.res !== undefined) {
-                    return new workflow_1.RetrievedHandle(this.systemDatabase, cr.res.child, callerID, callerFunctionID);
+                const result = await this.systemDatabase.getOperationResultAndThrowIfCancelled(callerID, callerFunctionID);
+                if (result) {
+                    return new workflow_1.RetrievedHandle(this.systemDatabase, result.childWorkflowID, callerID, callerFunctionID);
                 }
             }
-            const ires = await this.systemDatabase.initWorkflowStatus(internalStatus, args, wCtxt.maxRecoveryAttempts);
+            const ires = await this.systemDatabase.initWorkflowStatus(internalStatus, utils_1.DBOSJSON.stringify(args), wCtxt.maxRecoveryAttempts);
             if (callerFunctionID !== undefined && callerID !== undefined) {
-                await this.systemDatabase.recordOperationResult(callerID, callerFunctionID, {
-                    childWfId: workflowID,
-                    functionName: internalStatus.workflowName,
-                }, true);
+                await this.systemDatabase.recordOperationResult(callerID, callerFunctionID, internalStatus.workflowName, true, {
+                    childWorkflowID: workflowID,
+                });
             }
-            args = ires.args;
+            args = utils_1.DBOSJSON.parse(ires.serializedInputs);
             status = ires.status;
             await (0, debugpoint_1.debugTriggerPoint)(debugpoint_1.DEBUG_TRIGGER_WORKFLOW_ENQUEUE);
         }
@@ -637,7 +630,7 @@ class DBOSExecutor {
                 wCtxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
             }
             catch (err) {
-                if (err instanceof error_1.DBOSWorkflowConflictUUIDError) {
+                if (err instanceof error_1.DBOSWorkflowConflictError) {
                     // Retrieve the handle and wait for the result.
                     const retrievedHandle = this.retrieveWorkflow(workflowID);
                     result = await retrievedHandle.getResult();
@@ -683,16 +676,7 @@ class DBOSExecutor {
         if (this.isDebugging ||
             (status !== 'SUCCESS' && status !== 'ERROR' && (params.queueName === undefined || params.executeWorkflow))) {
             const workflowPromise = runWorkflow();
-            // Need to await for the workflow and capture errors.
-            const awaitWorkflowPromise = workflowPromise
-                .catch((error) => {
-                this.logger.debug('Captured error in awaitWorkflowPromise: ' + error);
-            })
-                .finally(() => {
-                // Remove itself from pending workflow map.
-                this.pendingWorkflowMap.delete(workflowID);
-            });
-            this.pendingWorkflowMap.set(workflowID, awaitWorkflowPromise);
+            this.systemDatabase.registerRunningWorkflow(workflowID, workflowPromise);
             // Return the normal handle that doesn't capture errors.
             return new workflow_1.InvokedHandle(this.systemDatabase, workflowPromise, workflowID, wf.name, callerID, callerFunctionID);
         }
@@ -769,7 +753,7 @@ class DBOSExecutor {
         catch (error) {
             if (isKeyConflict(error)) {
                 // Serialization and primary key conflict (Postgres).
-                throw new error_1.DBOSWorkflowConflictUUIDError(workflowUUID);
+                throw new error_1.DBOSWorkflowConflictError(workflowUUID);
             }
             else {
                 throw error;
@@ -790,7 +774,7 @@ class DBOSExecutor {
         catch (error) {
             if (isKeyConflict(error)) {
                 // Serialization and primary key conflict (Postgres).
-                throw new error_1.DBOSWorkflowConflictUUIDError(workflowUUID);
+                throw new error_1.DBOSWorkflowConflictError(workflowUUID);
             }
             else {
                 throw error;
@@ -826,9 +810,7 @@ class DBOSExecutor {
         if (txnInfo === undefined) {
             throw new error_1.DBOSNotRegisteredError(txn.name);
         }
-        if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
-            throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
-        }
+        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
         let retryWaitMillis = 1;
         const backoffFactor = 1.5;
         const maxRetryWaitMs = 2000; // Maximum wait 2 seconds.
@@ -842,9 +824,7 @@ class DBOSExecutor {
             isolationLevel: txnInfo.config.isolationLevel,
         }, wfCtx.span);
         while (true) {
-            if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
-                throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
-            }
+            await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
             let txn_snapshot = 'invalid';
             const workflowUUID = wfCtx.workflowUUID;
             const wrappedTransaction = async (client) => {
@@ -978,9 +958,7 @@ class DBOSExecutor {
         if (procInfo === undefined) {
             throw new error_1.DBOSNotRegisteredError(proc.name);
         }
-        if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
-            throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
-        }
+        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
         const executeLocally = this.isDebugging || (procInfo.config.executeLocally ?? false);
         const funcId = wfCtx.functionIDGetIncrement();
         const span = this.tracer.startSpan(proc.name, {
@@ -1013,9 +991,7 @@ class DBOSExecutor {
         const backoffFactor = 1.5;
         const maxRetryWaitMs = 2000; // Maximum wait 2 seconds.
         while (true) {
-            if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
-                throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
-            }
+            await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
             let txn_snapshot = 'invalid';
             const wrappedProcedure = async (client) => {
                 const ctxt = new procedure_1.StoredProcedureContextImpl(client, wfCtx, span, this.logger, funcId, proc.name);
@@ -1124,9 +1100,7 @@ class DBOSExecutor {
         if (this.isDebugging) {
             throw new error_1.DBOSDebuggerError("Can't invoke stored procedure in debug mode.");
         }
-        if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
-            throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
-        }
+        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
         const $jsonCtx = {
             request: wfCtx.request,
             authenticatedUser: wfCtx.authenticatedUser,
@@ -1217,9 +1191,7 @@ class DBOSExecutor {
         if (commInfo === undefined) {
             throw new error_1.DBOSNotRegisteredError(stepFn.name);
         }
-        if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
-            throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
-        }
+        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
         const funcID = wfCtx.functionIDGetIncrement();
         const maxRetryIntervalSec = 3600; // Maximum retry interval: 1 hour
         const span = this.tracer.startSpan(stepFn.name, {
@@ -1235,12 +1207,12 @@ class DBOSExecutor {
         }, wfCtx.span);
         const ctxt = new step_1.StepContextImpl(wfCtx, funcID, span, this.logger, commInfo.config, stepFn.name);
         // Check if this execution previously happened, returning its original result if it did.
-        const checkr = await this.systemDatabase.getOperationResult(wfCtx.workflowUUID, ctxt.functionID);
-        if (checkr.res !== undefined) {
-            if (checkr.res.functionName !== ctxt.operationName) {
-                throw new error_1.DBOSUnexpectedStepError(ctxt.workflowUUID, ctxt.functionID, ctxt.operationName, checkr.res.functionName ?? '?');
+        const checkr = await this.systemDatabase.getOperationResultAndThrowIfCancelled(wfCtx.workflowUUID, ctxt.functionID);
+        if (checkr) {
+            if (checkr.functionName !== ctxt.operationName) {
+                throw new error_1.DBOSUnexpectedStepError(ctxt.workflowUUID, ctxt.functionID, ctxt.operationName, checkr.functionName ?? '?');
             }
-            const check = DBOSExecutor.reviveResultOrError(checkr.res);
+            const check = DBOSExecutor.reviveResultOrError(checkr);
             ctxt.span.setAttribute('cached', true);
             ctxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
             this.tracer.endSpan(ctxt.span);
@@ -1262,9 +1234,7 @@ class DBOSExecutor {
             }
             while (result === exports.dbosNull && numAttempts++ < ctxt.maxAttempts) {
                 try {
-                    if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
-                        throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
-                    }
+                    await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
                     let cresult;
                     if (commInfo.registration.passContext) {
                         await (0, context_1.runWithStepContext)(ctxt, numAttempts, async () => {
@@ -1318,20 +1288,18 @@ class DBOSExecutor {
         if (result === exports.dbosNull) {
             // Record the error, then throw it.
             err = err === exports.dbosNull ? new error_1.DBOSMaxStepRetriesError(stepFn.name, ctxt.maxAttempts, errors) : err;
-            await this.systemDatabase.recordOperationResult(wfCtx.workflowUUID, ctxt.functionID, {
-                serialError: utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(err)),
-                functionName: ctxt.operationName,
-            }, true);
+            await this.systemDatabase.recordOperationResult(wfCtx.workflowUUID, ctxt.functionID, ctxt.operationName, true, {
+                error: utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(err)),
+            });
             ctxt.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: err.message });
             this.tracer.endSpan(ctxt.span);
             throw err;
         }
         else {
             // Record the execution and return.
-            await this.systemDatabase.recordOperationResult(wfCtx.workflowUUID, ctxt.functionID, {
-                serialOutput: utils_1.DBOSJSON.stringify(result),
-                functionName: ctxt.operationName,
-            }, true);
+            await this.systemDatabase.recordOperationResult(wfCtx.workflowUUID, ctxt.functionID, ctxt.operationName, true, {
+                output: utils_1.DBOSJSON.stringify(result),
+            });
             ctxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
             this.tracer.endSpan(ctxt.span);
             return result;
@@ -1355,49 +1323,13 @@ class DBOSExecutor {
     async getEvent(workflowUUID, key, timeoutSeconds = DBOSExecutor.defaultNotificationTimeoutSec) {
         return utils_1.DBOSJSON.parse(await this.systemDatabase.getEvent(workflowUUID, key, timeoutSeconds));
     }
-    async getMaxFunctionID(workflowID) {
-        const rows = await this.userDatabase.query(`SELECT max(function_id) as max_function_id FROM ${DBOSExecutor.systemDBSchemaName}.transaction_outputs WHERE workflow_uuid=$1`, workflowID);
-        if (rows.length === 0) {
-            return 0;
-        }
-        else {
-            return rows[0].max_function_id;
-        }
-    }
-    async cloneWorkflowTransactions(workflowID, forkedWorkflowUUID, startStep) {
-        const query = `
-      INSERT INTO dbos.transaction_outputs
-        (workflow_uuid,
-          function_id, 
-          output, 
-          error, 
-          txn_id, 
-          txn_snapshot,  
-          function_name)
-      SELECT $1 AS workflow_uuid, 
-          function_id, 
-          output, 
-          error, 
-          txn_id, 
-          txn_snapshot, 
-          function_name
-      FROM dbos.transaction_outputs WHERE workflow_uuid= $2 AND function_id < $3`;
-        await this.userDatabase.query(query, forkedWorkflowUUID, workflowID, startStep);
-    }
-    async getMaxStepID(workflowID) {
-        const maxAppFunctionID = await this.getMaxFunctionID(workflowID);
-        const maxSystemFunctionID = await this.systemDatabase.getMaxFunctionID(workflowID);
-        return Math.max(maxAppFunctionID, maxSystemFunctionID);
-    }
     /**
      * Fork a workflow.
      * The forked workflow will be assigned a new ID.
      */
-    async forkWorkflow(workflowID, startStep = 0) {
-        const forkedWorkflowID = this.#generateUUID();
-        await this.cloneWorkflowTransactions(workflowID, forkedWorkflowID, startStep);
-        await this.systemDatabase.forkWorkflow(workflowID, forkedWorkflowID, startStep);
-        return forkedWorkflowID;
+    forkWorkflow(workflowID, startStep, options = {}) {
+        const newWorkflowID = options.newWorkflowID ?? (0, context_1.getNextWFID)(undefined);
+        return (0, workflow_management_1.forkWorkflow)(this.systemDatabase, this.userDatabase, workflowID, startStep, { ...options, newWorkflowID });
     }
     /**
      * Retrieve a handle for a workflow UUID.
@@ -1405,41 +1337,49 @@ class DBOSExecutor {
     retrieveWorkflow(workflowID) {
         return new workflow_1.RetrievedHandle(this.systemDatabase, workflowID);
     }
-    async runAsStep(callback, functionName, workflowID, functionID) {
+    async runAsStep(callback, functionName, workflowID, functionID, childWfId) {
         if (workflowID !== undefined && functionID !== undefined) {
-            const res = await this.systemDatabase.getOperationResult(workflowID, functionID);
-            if (res.res !== undefined) {
-                if (res.res.functionName !== functionName) {
-                    throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, functionName, res.res.functionName);
+            const result = await this.systemDatabase.getOperationResultAndThrowIfCancelled(workflowID, functionID);
+            if (result) {
+                if (result.functionName !== functionName) {
+                    throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, functionName, result.functionName);
                 }
-                return DBOSExecutor.reviveResultOrError(res.res);
+                return DBOSExecutor.reviveResultOrError(result);
             }
         }
         try {
             const output = await callback();
             if (workflowID !== undefined && functionID !== undefined) {
-                await this.systemDatabase.recordOperationResult(workflowID, functionID, { serialOutput: utils_1.DBOSJSON.stringify(output), functionName }, true);
+                await this.systemDatabase.recordOperationResult(workflowID, functionID, functionName, true, {
+                    output: utils_1.DBOSJSON.stringify(output),
+                    childWorkflowID: childWfId,
+                });
             }
             return output;
         }
         catch (e) {
             if (workflowID !== undefined && functionID !== undefined) {
-                await this.systemDatabase.recordOperationResult(workflowID, functionID, { serialError: utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(e)), functionName }, false);
+                await this.systemDatabase.recordOperationResult(workflowID, functionID, functionName, false, {
+                    error: utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(e)),
+                    childWorkflowID: childWfId,
+                });
             }
             throw e;
         }
     }
     async getWorkflowStatus(workflowID, callerID, callerFN) {
+        // use sysdb getWorkflowStatus directly in order to support caller ID/FN params
         const status = await this.systemDatabase.getWorkflowStatus(workflowID, callerID, callerFN);
-        return status ? DBOSExecutor.toWorkflowStatus(status, true) : null;
+        return status ? (0, workflow_management_1.toWorkflowStatus)(status) : null;
     }
     async listWorkflows(input) {
-        const wfs = await this.systemDatabase.listWorkflows(input);
-        return wfs.map((wf) => DBOSExecutor.toWorkflowStatus(wf, true));
+        return (0, workflow_management_1.listWorkflows)(this.systemDatabase, input);
     }
     async listQueuedWorkflows(input) {
-        const wfs = await this.systemDatabase.listQueuedWorkflows(input);
-        return wfs.map((wf) => DBOSExecutor.toWorkflowStatus(wf, true));
+        return (0, workflow_management_1.listQueuedWorkflows)(this.systemDatabase, input);
+    }
+    async listWorkflowSteps(workflowID) {
+        return (0, workflow_management_1.listWorkflowSteps)(this.systemDatabase, this.userDatabase, workflowID);
     }
     getWorkflowQueue(input) {
         return this.systemDatabase.getWorkflowQueue(input);
@@ -1473,9 +1413,6 @@ class DBOSExecutor {
         };
     }
     /* INTERNAL HELPERS */
-    #generateUUID() {
-        return (0, node_crypto_1.randomUUID)();
-    }
     /**
      * A recovery process that by default runs during executor init time.
      * It runs to completion all pending workflows that were executing when the previous executor failed.
@@ -1526,7 +1463,7 @@ class DBOSExecutor {
             await evtRcvr.initialize(this);
         }
     }
-    async deactivateEventReceivers() {
+    async deactivateEventReceivers(stopQueueThread = true) {
         this.logger.debug('Deactivating event receivers');
         for (const evtRcvr of this.eventReceivers || []) {
             try {
@@ -1544,23 +1481,28 @@ class DBOSExecutor {
             const e = err;
             this.logger.warn(`Error destroying scheduler: ${e.message}`);
         }
-        try {
-            wfqueue_1.wfQueueRunner.stop();
-            await this.wfqEnded;
-        }
-        catch (err) {
-            const e = err;
-            this.logger.warn(`Error destroying wf queue runner: ${e.message}`);
+        if (stopQueueThread) {
+            try {
+                wfqueue_1.wfQueueRunner.stop();
+                await this.wfqEnded;
+            }
+            catch (err) {
+                const e = err;
+                this.logger.warn(`Error destroying wf queue runner: ${e.message}`);
+            }
         }
     }
     async executeWorkflowUUID(workflowID, startNewWorkflow = false) {
-        // TODO: remove call to getWorkflowInputs after #871 is merged
         const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowID);
-        const inputs = await this.systemDatabase.getWorkflowInputs(workflowID);
-        if (!inputs || !wfStatus) {
+        if (!wfStatus) {
+            this.logger.error(`Failed to find workflow status for workflowUUID: ${workflowID}`);
+            throw new error_1.DBOSError(`Failed to find workflow status for workflow UUID: ${workflowID}`);
+        }
+        if (!wfStatus?.input) {
             this.logger.error(`Failed to find inputs for workflowUUID: ${workflowID}`);
             throw new error_1.DBOSError(`Failed to find inputs for workflow UUID: ${workflowID}`);
         }
+        const inputs = utils_1.DBOSJSON.parse(wfStatus.input);
         const parentCtx = this.#getRecoveryContext(workflowID, wfStatus);
         const { wfInfo, configuredInst } = this.getWorkflowInfoByStatus(wfStatus);
         // If starting a new workflow, assign a new UUID. Otherwise, use the workflow's original UUID.
@@ -1572,9 +1514,7 @@ class DBOSExecutor {
                 configuredInstance: configuredInst,
                 queueName: wfStatus.queueName,
                 executeWorkflow: true,
-            }, 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            ...inputs);
+            }, ...inputs);
         }
         // Should be temporary workflows. Parse the name of the workflow.
         const wfName = wfStatus.workflowName;
@@ -1596,9 +1536,7 @@ class DBOSExecutor {
                 configuredInstance: clsInst,
                 queueName: wfStatus.queueName,
                 executeWorkflow: true,
-            }, undefined, undefined, 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            ...inputs);
+            }, undefined, undefined, ...inputs);
         }
         else if (nameArr[1] === exports.TempWorkflowType.step) {
             const { commInfo, clsInst } = this.getStepInfoByNames(wfStatus.workflowClassName, nameArr[2], wfStatus.workflowConfigName);
@@ -1612,9 +1550,7 @@ class DBOSExecutor {
                 configuredInstance: clsInst,
                 queueName: wfStatus.queueName, // Probably null
                 executeWorkflow: true,
-            }, undefined, undefined, 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            ...inputs);
+            }, undefined, undefined, ...inputs);
         }
         else if (nameArr[1] === exports.TempWorkflowType.send) {
             temp_workflow = async (ctxt, ...args) => {
@@ -1626,9 +1562,7 @@ class DBOSExecutor {
                 tempWfType: exports.TempWorkflowType.send,
                 queueName: wfStatus.queueName,
                 executeWorkflow: true,
-            }, 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            ...inputs);
+            }, ...inputs);
         }
         else {
             this.logger.error(`Unrecognized temporary workflow! UUID ${workflowID}, name ${wfName}`);
@@ -1654,7 +1588,6 @@ class DBOSExecutor {
     async cancelWorkflow(workflowID) {
         await this.systemDatabase.cancelWorkflow(workflowID);
         this.logger.info(`Cancelling workflow ${workflowID}`);
-        this.workflowCancellationMap.set(workflowID, true);
     }
     async getWorkflowSteps(workflowID) {
         const outputs = await this.systemDatabase.getAllOperationResults(workflowID);
@@ -1668,15 +1601,7 @@ class DBOSExecutor {
             };
         });
     }
-    async listWorkflowSteps(workflowID) {
-        const steps = await this.getWorkflowSteps(workflowID);
-        const transactions = await this.getTransactions(workflowID);
-        const merged = [...steps, ...transactions];
-        merged.sort((a, b) => a.function_id - b.function_id);
-        return merged;
-    }
     async resumeWorkflow(workflowID) {
-        this.workflowCancellationMap.delete(workflowID);
         await this.systemDatabase.resumeWorkflow(workflowID);
     }
     logRegisteredHTTPUrls() {
@@ -1722,30 +1647,7 @@ class DBOSExecutor {
         if (DBOSExecutor.internalQueue !== undefined) {
             return;
         }
-        DBOSExecutor.internalQueue = new wfqueue_1.WorkflowQueue(utils_1.INTERNAL_QUEUE_NAME);
-    }
-    static toWorkflowStatus(internal, getRequest = true) {
-        return {
-            workflowID: internal.workflowUUID,
-            status: internal.status,
-            workflowName: internal.workflowName,
-            workflowClassName: internal.workflowClassName,
-            workflowConfigName: internal.workflowConfigName,
-            queueName: internal.queueName,
-            authenticatedUser: internal.authenticatedUser,
-            assumedRole: internal.assumedRole,
-            authenticatedRoles: internal.authenticatedRoles,
-            input: internal.input ? utils_1.DBOSJSON.parse(internal.input) : undefined,
-            output: internal.output ? utils_1.DBOSJSON.parse(internal.output ?? null) : undefined,
-            error: internal.error ? (0, serialize_error_1.deserializeError)(utils_1.DBOSJSON.parse(internal.error)) : undefined,
-            request: getRequest ? internal.request : undefined,
-            executorId: internal.executorId,
-            applicationVersion: internal.applicationVersion,
-            applicationID: internal.applicationID,
-            recoveryAttempts: internal.recoveryAttempts,
-            createdAt: internal.createdAt,
-            updatedAt: internal.updatedAt,
-        };
+        DBOSExecutor.internalQueue = new wfqueue_1.WorkflowQueue(utils_1.INTERNAL_QUEUE_NAME, {});
     }
 }
 exports.DBOSExecutor = DBOSExecutor;