@dbos-inc/dbos-sdk 2.8.13-preview → 2.8.18-preview

package/dist/src/dbos-executor.js

@@ -190,24 +190,12 @@ class DBOSExecutor {
             // TODO: make Prisma work with debugger proxy.
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports
             const { PrismaClient } = require(node_path_1.default.join(process.cwd(), 'node_modules', '@prisma', 'client')); // Find the prisma client in the node_modules of the current project
-            let dbUrl = `postgresql://${userDBConfig.user}:${userDBConfig.password}@${userDBConfig.host}:${userDBConfig.port}/${userDBConfig.database}`;
-            const queryParams = {};
-            if (userDBConfig.connectionTimeoutMillis) {
-                queryParams['connect_timeout'] = userDBConfig.connectionTimeoutMillis;
-            }
-            if (userDBConfig.max) {
-                queryParams['connection_limit'] = String(userDBConfig.max);
-            }
-            const queryString = new URLSearchParams(queryParams).toString();
-            if (queryString) {
-                dbUrl += `?${queryString}`;
-            }
             this.userDatabase = new user_database_1.PrismaUserDatabase(
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call
             new PrismaClient({
                 datasources: {
                     db: {
-                        url: dbUrl,
+                        url: userDBConfig.connectionString,
                     },
                 },
             }));
@@ -220,16 +208,11 @@ class DBOSExecutor {
                 this.userDatabase = new user_database_1.TypeORMDatabase(
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
                 new DataSourceExports.DataSource({
-                    type: 'postgres', // perhaps should move to config file
-                    host: userDBConfig.host,
-                    port: userDBConfig.port,
-                    username: userDBConfig.user,
-                    password: userDBConfig.password,
-                    database: userDBConfig.database,
+                    type: 'postgres',
+                    url: userDBConfig.connectionString,
+                    connectTimeoutMS: userDBConfig.connectionTimeoutMillis,
                     entities: this.typeormEntities,
-                    ssl: userDBConfig.ssl,
                     poolSize: userDBConfig.max,
-                    connectTimeoutMS: userDBConfig.connectionTimeoutMillis,
                 }));
             }
             catch (s) {
@@ -242,13 +225,8 @@ class DBOSExecutor {
             const knexConfig = {
                 client: 'postgres',
                 connection: {
-                    host: userDBConfig.host,
-                    port: userDBConfig.port,
-                    user: userDBConfig.user,
-                    password: userDBConfig.password,
-                    database: userDBConfig.database,
-                    ssl: userDBConfig.ssl,
-                    connectTimeout: userDBConfig.connectionTimeoutMillis,
+                    connectionString: userDBConfig.connectionString,
+                    connectionTimeoutMillis: userDBConfig.connectionTimeoutMillis,
                 },
                 pool: {
                     min: 0,
@@ -542,30 +520,38 @@ class DBOSExecutor {
         return this.procedureInfoMap.get(pfName);
     }
     // TODO: getProcedureInfoByNames??
+    static reviveResultOrError(r, success) {
+        if (success === true || !r.err) {
+            return utils_1.DBOSJSON.parse(r.res ?? null);
+        }
+        else {
+            throw (0, serialize_error_1.deserializeError)(utils_1.DBOSJSON.parse(r.err));
+        }
+    }
     async workflow(wf, params, ...args) {
         return this.internalWorkflow(wf, params, undefined, undefined, ...args);
     }
     // If callerUUID and functionID are set, it means the workflow is invoked from within a workflow.
-    async internalWorkflow(wf, params, callerUUID, callerFunctionID, ...args) {
-        const workflowUUID = params.workflowUUID ? params.workflowUUID : this.#generateUUID();
-        const presetUUID = params.workflowUUID ? true : false;
+    async internalWorkflow(wf, params, callerID, callerFunctionID, ...args) {
+        const workflowID = params.workflowUUID ? params.workflowUUID : this.#generateUUID();
+        const presetID = params.workflowUUID ? true : false;
         const wInfo = this.getWorkflowInfo(wf);
         if (wInfo === undefined) {
             throw new error_1.DBOSNotRegisteredError(wf.name);
         }
         const wConfig = wInfo.config;
         const passContext = wInfo.registration?.passContext ?? true;
-        const wCtxt = new workflow_1.WorkflowContextImpl(this, params.parentCtx, workflowUUID, wConfig, wf.name, presetUUID, params.tempWfType, params.tempWfName);
+        const wCtxt = new workflow_1.WorkflowContextImpl(this, params.parentCtx, workflowID, wConfig, wf.name, presetID, params.tempWfType, params.tempWfName);
         const internalStatus = {
-            workflowUUID: workflowUUID,
+            workflowUUID: workflowID,
             status: params.queueName !== undefined ? workflow_1.StatusString.ENQUEUED : workflow_1.StatusString.PENDING,
             workflowName: wf.name,
             workflowClassName: wCtxt.isTempWorkflow ? '' : (0, decorators_1.getRegisteredMethodClassName)(wf),
             workflowConfigName: params.configuredInstance?.name || '',
             queueName: params.queueName,
             authenticatedUser: wCtxt.authenticatedUser,
-            output: undefined,
-            error: '',
+            output: null,
+            error: null,
             assumedRole: wCtxt.assumedRole,
             authenticatedRoles: wCtxt.authenticatedRoles,
             request: wCtxt.request,
@@ -583,28 +569,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) {
-            const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowUUID);
-            const wfInputs = await this.systemDatabase.getWorkflowInputs(workflowUUID);
+            const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowID);
+            const wfInputs = await this.systemDatabase.getWorkflowInputs(workflowID);
             if (!wfStatus || !wfInputs) {
-                throw new error_1.DBOSDebuggerError(`Failed to find inputs for workflow UUID ${workflowUUID}`);
+                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 ${workflowUUID}.\n Received: ${utils_1.DBOSJSON.stringify(args)}\n Original: ${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)}`);
             }
             status = wfStatus.status;
         }
         else {
             // TODO: Make this transactional (and with the queue step below)
-            if (callerFunctionID !== undefined && callerUUID !== undefined) {
-                const child_id = await this.systemDatabase.checkChildWorkflow(callerUUID, callerFunctionID);
-                if (child_id !== null) {
-                    return new workflow_1.RetrievedHandle(this.systemDatabase, child_id, callerUUID, callerFunctionID);
+            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 ires = await this.systemDatabase.initWorkflowStatus(internalStatus, args);
-            if (callerFunctionID !== undefined && callerUUID !== undefined) {
-                await this.systemDatabase.recordChildWorkflow(callerUUID, workflowUUID, callerFunctionID, internalStatus.workflowName);
+            if (callerFunctionID !== undefined && callerID !== undefined) {
+                await this.systemDatabase.recordOperationResult(callerID, callerFunctionID, {
+                    childWfId: workflowID,
+                    functionName: internalStatus.workflowName,
+                }, true);
             }
             args = ires.args;
             status = ires.status;
@@ -621,9 +610,9 @@ class DBOSExecutor {
                     return await callPromise;
                 });
                 if (this.isDebugging) {
-                    const recordedResult = await this.systemDatabase.getWorkflowResult(workflowUUID);
+                    const recordedResult = DBOSExecutor.reviveResultOrError((await this.systemDatabase.awaitWorkflowResult(workflowID)));
                     if (!resultsMatch(recordedResult, callResult)) {
-                        this.logger.error(`Detect different output for the workflow UUID ${workflowUUID}!\n Received: ${utils_1.DBOSJSON.stringify(callResult)}\n Original: ${utils_1.DBOSJSON.stringify(recordedResult)}`);
+                        this.logger.error(`Detect different output for the workflow UUID ${workflowID}!\n Received: ${utils_1.DBOSJSON.stringify(callResult)}\n Original: ${utils_1.DBOSJSON.stringify(recordedResult)}`);
                     }
                     result = recordedResult;
                 }
@@ -636,23 +625,20 @@ class DBOSExecutor {
                     }
                     return utils_1.DBOSJSON.stringify(recordedResult) === utils_1.DBOSJSON.stringify(callResult);
                 }
-                internalStatus.output = result;
+                internalStatus.output = utils_1.DBOSJSON.stringify(result);
                 internalStatus.status = workflow_1.StatusString.SUCCESS;
                 if (internalStatus.queueName && !this.isDebugging) {
-                    // Now... the workflow isn't certainly done.
-                    //  But waiting this long is for concurrency control anyway,
-                    //   so it is probably done enough.
-                    await this.systemDatabase.dequeueWorkflow(workflowUUID, this.#getQueueByName(internalStatus.queueName));
+                    await this.systemDatabase.dequeueWorkflow(workflowID, this.#getQueueByName(internalStatus.queueName));
                 }
                 if (!this.isDebugging) {
-                    await this.systemDatabase.recordWorkflowOutput(workflowUUID, internalStatus);
+                    await this.systemDatabase.recordWorkflowOutput(workflowID, internalStatus);
                 }
                 wCtxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
             }
             catch (err) {
                 if (err instanceof error_1.DBOSWorkflowConflictUUIDError) {
                     // Retrieve the handle and wait for the result.
-                    const retrievedHandle = this.retrieveWorkflow(workflowUUID);
+                    const retrievedHandle = this.retrieveWorkflow(workflowID);
                     result = await retrievedHandle.getResult();
                     wCtxt.span.setAttribute('cached', true);
                     wCtxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
@@ -661,10 +647,10 @@ class DBOSExecutor {
                     internalStatus.error = err.message;
                     internalStatus.status = workflow_1.StatusString.CANCELLED;
                     if (!this.isDebugging) {
-                        await this.systemDatabase.setWorkflowStatus(workflowUUID, workflow_1.StatusString.CANCELLED, false);
+                        await this.systemDatabase.setWorkflowStatus(workflowID, workflow_1.StatusString.CANCELLED, false);
                     }
                     wCtxt.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: err.message });
-                    this.logger.info(`Cancelled workflow ${workflowUUID}`);
+                    this.logger.info(`Cancelled workflow ${workflowID}`);
                     throw err;
                 }
                 else {
@@ -678,10 +664,10 @@ class DBOSExecutor {
                     internalStatus.error = utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(e));
                     internalStatus.status = workflow_1.StatusString.ERROR;
                     if (internalStatus.queueName && !this.isDebugging) {
-                        await this.systemDatabase.dequeueWorkflow(workflowUUID, this.#getQueueByName(internalStatus.queueName));
+                        await this.systemDatabase.dequeueWorkflow(workflowID, this.#getQueueByName(internalStatus.queueName));
                     }
                     if (!this.isDebugging) {
-                        await this.systemDatabase.recordWorkflowError(workflowUUID, internalStatus);
+                        await this.systemDatabase.recordWorkflowError(workflowID, internalStatus);
                     }
                     // TODO: Log errors, but not in the tests when they're expected.
                     wCtxt.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: e.message });
@@ -703,17 +689,17 @@ class DBOSExecutor {
             })
                 .finally(() => {
                 // Remove itself from pending workflow map.
-                this.pendingWorkflowMap.delete(workflowUUID);
+                this.pendingWorkflowMap.delete(workflowID);
             });
-            this.pendingWorkflowMap.set(workflowUUID, awaitWorkflowPromise);
+            this.pendingWorkflowMap.set(workflowID, awaitWorkflowPromise);
             // Return the normal handle that doesn't capture errors.
-            return new workflow_1.InvokedHandle(this.systemDatabase, workflowPromise, workflowUUID, wf.name, callerUUID, callerFunctionID);
+            return new workflow_1.InvokedHandle(this.systemDatabase, workflowPromise, workflowID, wf.name, callerID, callerFunctionID);
         }
         else {
             if (params.queueName && status === 'ENQUEUED' && !this.isDebugging) {
-                await this.systemDatabase.enqueueWorkflow(workflowUUID, this.#getQueueByName(params.queueName).name);
+                await this.systemDatabase.enqueueWorkflow(workflowID, this.#getQueueByName(params.queueName).name);
             }
-            return new workflow_1.RetrievedHandle(this.systemDatabase, workflowUUID, callerUUID, callerFunctionID);
+            return new workflow_1.RetrievedHandle(this.systemDatabase, workflowID, callerID, callerFunctionID);
         }
     }
     #getQueueByName(name) {
@@ -736,14 +722,23 @@ class DBOSExecutor {
      * Otherwise, return DBOSNull.
      * Also return the transaction snapshot and id information of the original or current transaction.
      */
-    async #checkExecution(query, workflowUUID, funcID) {
-        const rows = await query('(SELECT output, error, txn_snapshot, txn_id, true as recorded FROM dbos.transaction_outputs WHERE workflow_uuid=$1 AND function_id=$2 UNION ALL SELECT null as output, null as error, pg_current_snapshot()::text as txn_snapshot, null as txn_id, false as recorded) ORDER BY recorded', [workflowUUID, funcID]);
+    async #checkExecution(query, workflowUUID, funcID, funcName) {
+        const rows = await query(`(SELECT output, error, txn_snapshot, txn_id, function_name, true as recorded
+          FROM dbos.transaction_outputs
+          WHERE workflow_uuid=$1 AND function_id=$2
+        UNION ALL
+          SELECT null as output, null as error, pg_current_snapshot()::text as txn_snapshot,
+                 null as txn_id, '' as function_name, false as recorded
+       ) ORDER BY recorded`, [workflowUUID, funcID]);
         if (rows.length === 0 || rows.length > 2) {
             const returnedRows = JSON.stringify(rows);
             this.logger.error('Unexpected! This should never happen. Returned rows: ' + returnedRows);
             throw new error_1.DBOSError('This should never happen. Returned rows: ' + returnedRows);
         }
         if (rows.length === 2) {
+            if (rows[1].function_name !== funcName) {
+                throw new error_1.DBOSUnexpectedStepError(workflowUUID, funcID, funcName, rows[0].function_name);
+            }
             const { txn_snapshot, txn_id } = rows[1];
             const error = utils_1.DBOSJSON.parse(rows[1].error);
             if (error) {
@@ -858,7 +853,7 @@ class DBOSExecutor {
                 let prevResult = exports.dbosNull;
                 const queryFunc = (sql, args) => this.userDatabase.queryWithClient(client, sql, ...args);
                 if (wfCtx.presetUUID) {
-                    const executionResult = await this.#checkExecution(queryFunc, workflowUUID, funcId);
+                    const executionResult = await this.#checkExecution(queryFunc, workflowUUID, funcId, txn.name);
                     prevResult = executionResult.result;
                     txn_snapshot = executionResult.txn_snapshot;
                     if (prevResult !== exports.dbosNull) {
@@ -941,7 +936,7 @@ class DBOSExecutor {
             }
             catch (err) {
                 const e = err;
-                if (!this.debugMode) {
+                if (!this.debugMode && !(e instanceof error_1.DBOSUnexpectedStepError)) {
                     if (this.userDatabase.isRetriableTransactionError(err)) {
                         // serialization_failure in PostgreSQL
                         span.addEvent('TXN SERIALIZATION FAILURE', { retryWaitMillis: retryWaitMillis }, performance.now());
@@ -1026,7 +1021,7 @@ class DBOSExecutor {
                 let prevResult = exports.dbosNull;
                 const queryFunc = (sql, args) => this.procedurePool.query(sql, args).then((v) => v.rows);
                 if (wfCtx.presetUUID) {
-                    const executionResult = await this.#checkExecution(queryFunc, wfCtx.workflowUUID, funcId);
+                    const executionResult = await this.#checkExecution(queryFunc, wfCtx.workflowUUID, funcId, wfCtx.operationName);
                     prevResult = executionResult.result;
                     txn_snapshot = executionResult.txn_snapshot;
                     if (prevResult !== exports.dbosNull) {
@@ -1239,8 +1234,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 check = await this.systemDatabase.checkOperationOutput(wfCtx.workflowUUID, ctxt.functionID);
-        if (check !== exports.dbosNull) {
+        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 check = DBOSExecutor.reviveResultOrError(checkr.res);
             ctxt.span.setAttribute('cached', true);
             ctxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
             this.tracer.endSpan(ctxt.span);
@@ -1318,14 +1317,20 @@ 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.recordOperationError(wfCtx.workflowUUID, ctxt.functionID, err, ctxt.operationName);
+            await this.systemDatabase.recordOperationResult(wfCtx.workflowUUID, ctxt.functionID, {
+                serialError: utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(err)),
+                functionName: ctxt.operationName,
+            }, true);
             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.recordOperationOutput(wfCtx.workflowUUID, ctxt.functionID, result, ctxt.operationName);
+            await this.systemDatabase.recordOperationResult(wfCtx.workflowUUID, ctxt.functionID, {
+                serialOutput: utils_1.DBOSJSON.stringify(result),
+                functionName: ctxt.operationName,
+            }, true);
             ctxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
             this.tracer.endSpan(ctxt.span);
             return result;
@@ -1347,7 +1352,7 @@ class DBOSExecutor {
      * Wait for a workflow to emit an event, then return its value.
      */
     async getEvent(workflowUUID, key, timeoutSeconds = DBOSExecutor.defaultNotificationTimeoutSec) {
-        return this.systemDatabase.getEvent(workflowUUID, key, timeoutSeconds);
+        return utils_1.DBOSJSON.parse(await this.systemDatabase.getEvent(workflowUUID, key, timeoutSeconds));
     }
     /**
      * Retrieve a handle for a workflow UUID.
@@ -1355,8 +1360,32 @@ class DBOSExecutor {
     retrieveWorkflow(workflowID) {
         return new workflow_1.RetrievedHandle(this.systemDatabase, workflowID);
     }
-    getWorkflowStatus(workflowID) {
-        return this.systemDatabase.getWorkflowStatus(workflowID);
+    async runAsStep(callback, functionName, workflowID, functionID) {
+        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);
+                }
+                return DBOSExecutor.reviveResultOrError(res.res);
+            }
+        }
+        try {
+            const output = await callback();
+            if (workflowID !== undefined && functionID !== undefined) {
+                await this.systemDatabase.recordOperationResult(workflowID, functionID, { serialOutput: utils_1.DBOSJSON.stringify(output), functionName }, true);
+            }
+            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);
+            }
+            throw e;
+        }
+    }
+    getWorkflowStatus(workflowID, callerID, callerFN) {
+        return this.systemDatabase.getWorkflowStatus(workflowID, callerID, callerFN);
     }
     getWorkflows(input) {
         return this.systemDatabase.getWorkflows(input);
@@ -1473,20 +1502,20 @@ class DBOSExecutor {
             this.logger.warn(`Error destroying wf queue runner: ${e.message}`);
         }
     }
-    async executeWorkflowUUID(workflowUUID, startNewWorkflow = false) {
-        const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowUUID);
-        const inputs = await this.systemDatabase.getWorkflowInputs(workflowUUID);
+    async executeWorkflowUUID(workflowID, startNewWorkflow = false) {
+        const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowID);
+        const inputs = await this.systemDatabase.getWorkflowInputs(workflowID);
         if (!inputs || !wfStatus) {
-            this.logger.error(`Failed to find inputs for workflowUUID: ${workflowUUID}`);
-            throw new error_1.DBOSError(`Failed to find inputs for workflow UUID: ${workflowUUID}`);
+            this.logger.error(`Failed to find inputs for workflowUUID: ${workflowID}`);
+            throw new error_1.DBOSError(`Failed to find inputs for workflow UUID: ${workflowID}`);
         }
-        const parentCtx = this.#getRecoveryContext(workflowUUID, wfStatus);
+        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.
-        const workflowStartUUID = startNewWorkflow ? undefined : workflowUUID;
+        const workflowStartID = startNewWorkflow ? undefined : workflowID;
         if (wfInfo) {
             return this.workflow(wfInfo.workflow, {
-                workflowUUID: workflowStartUUID,
+                workflowUUID: workflowStartID,
                 parentCtx: parentCtx,
                 configuredInstance: configuredInst,
                 queueName: wfStatus.queueName,
@@ -1500,17 +1529,17 @@ class DBOSExecutor {
         const nameArr = wfName.split('-');
         if (!nameArr[0].startsWith(DBOSExecutor.tempWorkflowName)) {
             // CB - Doesn't this happen if the user changed the function name in their code?
-            throw new error_1.DBOSError(`This should never happen! Cannot find workflow info for a non-temporary workflow! UUID ${workflowUUID}, name ${wfName}`);
+            throw new error_1.DBOSError(`This should never happen! Cannot find workflow info for a non-temporary workflow! UUID ${workflowID}, name ${wfName}`);
         }
         let temp_workflow;
         if (nameArr[1] === exports.TempWorkflowType.transaction) {
             const { txnInfo, clsInst } = this.getTransactionInfoByNames(wfStatus.workflowClassName, nameArr[2], wfStatus.workflowConfigName);
             if (!txnInfo) {
-                this.logger.error(`Cannot find transaction info for UUID ${workflowUUID}, name ${nameArr[2]}`);
+                this.logger.error(`Cannot find transaction info for UUID ${workflowID}, name ${nameArr[2]}`);
                 throw new error_1.DBOSNotRegisteredError(nameArr[2]);
             }
             return await this.startTransactionTempWF(txnInfo.transaction, {
-                workflowUUID: workflowStartUUID,
+                workflowUUID: workflowStartID,
                 parentCtx: parentCtx ?? undefined,
                 configuredInstance: clsInst,
                 queueName: wfStatus.queueName,
@@ -1522,11 +1551,11 @@ class DBOSExecutor {
         else if (nameArr[1] === exports.TempWorkflowType.step) {
             const { commInfo, clsInst } = this.getStepInfoByNames(wfStatus.workflowClassName, nameArr[2], wfStatus.workflowConfigName);
             if (!commInfo) {
-                this.logger.error(`Cannot find step info for UUID ${workflowUUID}, name ${nameArr[2]}`);
+                this.logger.error(`Cannot find step info for UUID ${workflowID}, name ${nameArr[2]}`);
                 throw new error_1.DBOSNotRegisteredError(nameArr[2]);
             }
             return await this.startStepTempWF(commInfo.step, {
-                workflowUUID: workflowStartUUID,
+                workflowUUID: workflowStartID,
                 parentCtx: parentCtx ?? undefined,
                 configuredInstance: clsInst,
                 queueName: wfStatus.queueName, // Probably null
@@ -1540,7 +1569,7 @@ class DBOSExecutor {
                 return await ctxt.send(args[0], args[1], args[2]); // id, value, topic
             };
             return this.workflow(temp_workflow, {
-                workflowUUID: workflowStartUUID,
+                workflowUUID: workflowStartID,
                 parentCtx: parentCtx ?? undefined,
                 tempWfType: exports.TempWorkflowType.send,
                 queueName: wfStatus.queueName,
@@ -1550,7 +1579,7 @@ class DBOSExecutor {
             ...inputs);
         }
         else {
-            this.logger.error(`Unrecognized temporary workflow! UUID ${workflowUUID}, name ${wfName}`);
+            this.logger.error(`Unrecognized temporary workflow! UUID ${workflowID}, name ${wfName}`);
             throw new error_1.DBOSNotRegisteredError(wfName);
         }
     }
@@ -1575,8 +1604,20 @@ class DBOSExecutor {
         this.logger.info(`Cancelling workflow ${workflowID}`);
         this.workflowCancellationMap.set(workflowID, true);
     }
+    async getWorkflowSteps(workflowID) {
+        const outputs = await this.systemDatabase.getAllOperationResults(workflowID);
+        return outputs.map((row) => {
+            return {
+                function_id: row.function_id,
+                function_name: row.function_name ?? '<unknown>',
+                child_workflow_id: row.child_workflow_id,
+                output: row.output !== null ? utils_1.DBOSJSON.parse(row.output) : null,
+                error: row.error !== null ? (0, serialize_error_1.deserializeError)(utils_1.DBOSJSON.parse(row.error)) : null,
+            };
+        });
+    }
     async listWorkflowSteps(workflowID) {
-        const steps = await this.systemDatabase.getWorkflowSteps(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);