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

package/dist/src/system_database.js

@@ -4,17 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresSystemDatabase = exports.migrateSystemDatabase = void 0;
-const serialize_error_1 = require("serialize-error");
+exports.PostgresSystemDatabase = exports.migrateSystemDatabase = exports.DBOS_FUNCNAME_GETSTATUS = exports.DBOS_FUNCNAME_SLEEP = exports.DBOS_FUNCNAME_GETEVENT = exports.DBOS_FUNCNAME_SETEVENT = exports.DBOS_FUNCNAME_RECV = exports.DBOS_FUNCNAME_SEND = void 0;
 const dbos_executor_1 = require("./dbos-executor");
 const pg_1 = require("pg");
 const error_1 = require("./error");
 const workflow_1 = require("./workflow");
 const utils_1 = require("./utils");
-const context_1 = require("./context");
 const knex_1 = __importDefault(require("knex"));
 const path_1 = __importDefault(require("path"));
-const context_2 = require("./context");
+exports.DBOS_FUNCNAME_SEND = 'DBOS.send';
+exports.DBOS_FUNCNAME_RECV = 'DBOS.recv';
+exports.DBOS_FUNCNAME_SETEVENT = 'DBOS.setEvent';
+exports.DBOS_FUNCNAME_GETEVENT = 'DBOS.getEvent';
+exports.DBOS_FUNCNAME_SLEEP = 'DBOS.sleep';
+exports.DBOS_FUNCNAME_GETSTATUS = 'getStatus';
 async function migrateSystemDatabase(systemPoolConfig, logger) {
     const migrationsDirectory = path_1.default.join((0, utils_1.findPackageRoot)(__dirname), 'migrations');
     const knexConfig = {
@@ -48,17 +51,19 @@ class PostgresSystemDatabase {
     notificationsClient = null;
     notificationsMap = {};
     workflowEventsMap = {};
-    static connectionTimeoutMillis = 10000; // 10 second timeout
     constructor(pgPoolConfig, systemDatabaseName, logger, sysDbPoolSize) {
         this.pgPoolConfig = pgPoolConfig;
         this.systemDatabaseName = systemDatabaseName;
         this.logger = logger;
         this.sysDbPoolSize = sysDbPoolSize;
-        this.systemPoolConfig = { ...pgPoolConfig };
-        this.systemPoolConfig.database = systemDatabaseName;
-        this.systemPoolConfig.connectionTimeoutMillis = PostgresSystemDatabase.connectionTimeoutMillis;
-        // This sets the application_name column in pg_stat_activity
-        this.systemPoolConfig.application_name = `dbos_transact_${utils_1.globalParams.executorID}_${utils_1.globalParams.appVersion}`;
+        // Craft a db string from the app db string, replacing the database name:
+        const systemDbConnectionString = new URL(pgPoolConfig.connectionString);
+        systemDbConnectionString.pathname = `/${systemDatabaseName}`;
+        this.systemPoolConfig = {
+            connectionString: systemDbConnectionString.toString(),
+            // This sets the application_name column in pg_stat_activity
+            application_name: `dbos_transact_${utils_1.globalParams.executorID}_${utils_1.globalParams.appVersion}`,
+        };
         this.pool = new pg_1.Pool(this.systemPoolConfig);
         const knexConfig = {
             client: 'pg',
@@ -201,83 +206,25 @@ class PostgresSystemDatabase {
         }
         return { args: utils_1.DBOSJSON.parse(rows[0].inputs), status };
     }
-    async recordWorkflowOutput(workflowUUID, status) {
-        await this.pool.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status (
-        workflow_uuid,
-        status,
-        name,
-        class_name,
-        config_name,
-        queue_name,
-        authenticated_user,
-        assumed_role,
-        authenticated_roles,
-        request,
-        output,
-        executor_id,
-        application_id,
-        application_version,
-        created_at,
-        updated_at
-    ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
-    ON CONFLICT (workflow_uuid)
-    DO UPDATE SET status=EXCLUDED.status, output=EXCLUDED.output, updated_at=EXCLUDED.updated_at;`, [
-            workflowUUID,
-            workflow_1.StatusString.SUCCESS,
-            status.workflowName,
-            status.workflowClassName,
-            status.workflowConfigName,
-            status.queueName,
-            status.authenticatedUser,
-            status.assumedRole,
-            utils_1.DBOSJSON.stringify(status.authenticatedRoles),
-            utils_1.DBOSJSON.stringify(status.request),
-            utils_1.DBOSJSON.stringify(status.output),
-            status.executorId,
-            status.applicationID,
-            status.applicationVersion,
-            status.createdAt,
-            Date.now(),
-        ]);
+    async recordWorkflowStatusChange(workflowID, status, update, client) {
+        let rec = '';
+        if (update.resetRecoveryAttempts) {
+            rec = ' recovery_attempts = 0, ';
+        }
+        if (update.incrementRecoveryAttempts) {
+            rec = ' recovery_attempts = recovery_attempts + 1';
+        }
+        const wRes = await (client ?? this.pool).query(`UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status
+       SET ${rec} status=$2, output=$3, error=$4, updated_at=$5 WHERE workflow_uuid=$1`, [workflowID, status, update.output, update.error, Date.now()]);
+        if (wRes.rowCount !== 1) {
+            throw new error_1.DBOSWorkflowConflictUUIDError(`Attempt to record transition of nonexistent workflow ${workflowID}`);
+        }
     }
-    async recordWorkflowError(workflowUUID, status) {
-        await this.pool.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status (
-        workflow_uuid,
-        status,
-        name,
-        class_name,
-        config_name,
-        queue_name,
-        authenticated_user,
-        assumed_role,
-        authenticated_roles,
-        request,
-        error,
-        executor_id,
-        application_id,
-        application_version,
-        created_at,
-        updated_at
-    ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
-    ON CONFLICT (workflow_uuid)
-    DO UPDATE SET status=EXCLUDED.status, error=EXCLUDED.error, updated_at=EXCLUDED.updated_at;`, [
-            workflowUUID,
-            workflow_1.StatusString.ERROR,
-            status.workflowName,
-            status.workflowClassName,
-            status.workflowConfigName,
-            status.queueName,
-            status.authenticatedUser,
-            status.assumedRole,
-            utils_1.DBOSJSON.stringify(status.authenticatedRoles),
-            utils_1.DBOSJSON.stringify(status.request),
-            status.error,
-            status.executorId,
-            status.applicationID,
-            status.applicationVersion,
-            status.createdAt,
-            Date.now(),
-        ]);
+    async recordWorkflowOutput(workflowID, status) {
+        await this.recordWorkflowStatusChange(workflowID, workflow_1.StatusString.SUCCESS, { output: status.output });
+    }
+    async recordWorkflowError(workflowID, status) {
+        await this.recordWorkflowStatusChange(workflowID, workflow_1.StatusString.ERROR, { error: status.error });
     }
     async getPendingWorkflows(executorID, appVersion) {
         const getWorkflows = await this.pool.query(`SELECT workflow_uuid, queue_name FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status WHERE status=$1 AND executor_id=$2 AND application_version=$3`, [workflow_1.StatusString.PENDING, executorID, appVersion]);
@@ -286,152 +233,111 @@ class PostgresSystemDatabase {
             queueName: i.queue_name,
         }));
     }
-    async getWorkflowInputs(workflowUUID) {
-        const { rows } = await this.pool.query(`SELECT inputs FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_inputs WHERE workflow_uuid=$1`, [workflowUUID]);
+    async getWorkflowInputs(workflowID) {
+        const { rows } = await this.pool.query(`SELECT inputs FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_inputs WHERE workflow_uuid=$1`, [workflowID]);
         if (rows.length === 0) {
             return null;
         }
         return utils_1.DBOSJSON.parse(rows[0].inputs);
     }
-    async checkOperationOutput(workflowUUID, functionID) {
-        const { rows } = await this.pool.query(`SELECT output, error FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs WHERE workflow_uuid=$1 AND function_id=$2`, [workflowUUID, functionID]);
+    async getOperationResult(workflowID, functionID, client) {
+        const { rows } = await (client ?? this.pool).query(`SELECT output, error, child_workflow_id, function_name
+       FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs
+      WHERE workflow_uuid=$1 AND function_id=$2`, [workflowID, functionID]);
         if (rows.length === 0) {
-            return dbos_executor_1.dbosNull;
-        }
-        else if (utils_1.DBOSJSON.parse(rows[0].error) !== null) {
-            throw (0, serialize_error_1.deserializeError)(utils_1.DBOSJSON.parse(rows[0].error));
-        }
-        else {
-            return utils_1.DBOSJSON.parse(rows[0].output);
-        }
-    }
-    async checkChildWorkflow(workflowUUID, functionID) {
-        const { rows } = await this.pool.query(`SELECT child_workflow_id FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs WHERE workflow_uuid=$1 AND function_id=$2`, [workflowUUID, functionID]);
-        if (rows.length > 0) {
-            return rows[0].child_workflow_id;
+            return {};
         }
         else {
-            return null;
+            return {
+                res: {
+                    res: rows[0].output,
+                    err: rows[0].error,
+                    child: rows[0].child_workflow_id,
+                    functionName: rows[0].function_name,
+                },
+            };
         }
     }
-    async getWorkflowSteps(workflowUUID) {
-        const { rows } = await this.pool.query(`SELECT function_id, function_name, output, error, child_workflow_id FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs WHERE workflow_uuid=$1`, [workflowUUID]);
-        for (const row of rows) {
-            row.output = row.output !== null ? utils_1.DBOSJSON.parse(row.output) : null;
-            row.error = row.error !== null ? (0, serialize_error_1.deserializeError)(utils_1.DBOSJSON.parse(row.error)) : null;
-        }
+    async getAllOperationResults(workflowID) {
+        const { rows } = await this.pool.query(`SELECT * FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs WHERE workflow_uuid=$1`, [workflowID]);
         return rows;
     }
-    async recordOperationOutput(workflowUUID, functionID, output, functionName) {
-        const serialOutput = utils_1.DBOSJSON.stringify(output);
+    async recordOperationResult(workflowID, functionID, rec, checkConflict, client) {
         try {
-            await this.pool.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs (workflow_uuid, function_id, output, function_name) VALUES ($1, $2, $3, $4);`, [workflowUUID, functionID, serialOutput, functionName]);
+            await (client ?? this.pool).query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs
+          (workflow_uuid, function_id, output, error, function_name, child_workflow_id)
+          VALUES ($1, $2, $3, $4, $5, $6)
+          ${checkConflict ? '' : ' ON CONFLICT DO NOTHING'}
+          ;`, [
+                workflowID,
+                functionID,
+                rec.serialOutput ?? null,
+                rec.serialError ?? null,
+                rec.functionName,
+                rec.childWfId ?? null,
+            ]);
         }
         catch (error) {
             const err = error;
             if (err.code === '40001' || err.code === '23505') {
                 // Serialization and primary key conflict (Postgres).
-                throw new error_1.DBOSWorkflowConflictUUIDError(workflowUUID);
+                throw new error_1.DBOSWorkflowConflictUUIDError(workflowID);
             }
             else {
                 throw err;
             }
         }
     }
-    async recordGetResult(resultWorkflowID, output, error) {
-        const ctx = (0, context_1.getCurrentContextStore)();
-        // Only record getResult called in workflow functions
-        if (ctx === undefined || !(0, context_1.isInWorkflowCtx)(ctx)) {
-            return;
-        }
-        // Record getResult as a step
-        const functionID = (0, context_1.assertCurrentWorkflowContext)().functionIDGetIncrement();
-        // Because there's no corresponding check, we do nothing on conflict
-        // and do not raise a DBOSWorkflowConflictUUIDError
-        await this.pool.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs (workflow_uuid, function_id, output, error, child_workflow_id, function_name) VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT DO NOTHING;`, [ctx.workflowId, functionID, output, error, resultWorkflowID, 'DBOS.getResult']);
-    }
-    async recordOperationError(workflowUUID, functionID, error, functionName) {
-        const serialErr = utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(error));
-        try {
-            await this.pool.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs (workflow_uuid, function_id, error, function_name) VALUES ($1, $2, $3, $4);`, [workflowUUID, functionID, serialErr, functionName]);
-        }
-        catch (error) {
-            const err = error;
-            if (err.code === '40001' || err.code === '23505') {
-                // Serialization and primary key conflict (Postgres).
-                throw new error_1.DBOSWorkflowConflictUUIDError(workflowUUID);
-            }
-            else {
-                throw err;
+    async runAsStep(callback, functionName, workflowID, functionID, client) {
+        if (workflowID !== undefined && functionID !== undefined) {
+            const res = await this.getOperationResult(workflowID, functionID, client);
+            if (res.res !== undefined) {
+                if (res.res.functionName !== functionName) {
+                    throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, functionName, res.res.functionName);
+                }
+                await client?.query('ROLLBACK');
+                return res.res.res;
             }
         }
-    }
-    async recordChildWorkflow(parentUUID, childUUID, functionID, functionName) {
-        try {
-            await this.pool.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs (workflow_uuid, function_id, function_name, child_workflow_id) VALUES ($1, $2, $3, $4);`, [parentUUID, functionID, functionName, childUUID]);
-        }
-        catch (error) {
-            const err = error;
-            if (err.code === '40001' || err.code === '23505') {
-                // Serialization and primary key conflict (Postgres).
-                throw new error_1.DBOSWorkflowConflictUUIDError(parentUUID);
-            }
-            else {
-                throw err;
-            }
+        const serialOutput = await callback();
+        if (workflowID !== undefined && functionID !== undefined) {
+            await this.recordOperationResult(workflowID, functionID, { serialOutput, functionName }, true, client);
         }
+        return serialOutput;
     }
-    /**
-     *  Guard the operation, throwing an error if a conflicting execution is detected.
-     */
-    async recordNotificationOutput(client, workflowUUID, functionID, output, functionName) {
-        try {
-            await client.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs (workflow_uuid, function_id, output, function_name) VALUES ($1, $2, $3, $4);`, [workflowUUID, functionID, utils_1.DBOSJSON.stringify(output), functionName]);
-        }
-        catch (error) {
-            const err = error;
-            if (err.code === '40001' || err.code === '23505') {
-                // Serialization and primary key conflict (Postgres).
-                throw new error_1.DBOSWorkflowConflictUUIDError(workflowUUID);
-            }
-            else {
-                throw err;
+    async durableSleepms(workflowID, functionID, durationMS) {
+        const curTime = Date.now();
+        let endTimeMs = curTime + durationMS;
+        const res = await this.getOperationResult(workflowID, functionID);
+        if (res.res !== undefined) {
+            if (res.res.functionName !== exports.DBOS_FUNCNAME_SLEEP) {
+                throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, exports.DBOS_FUNCNAME_SLEEP, res.res.functionName);
             }
-        }
-    }
-    async durableSleepms(workflowUUID, functionID, durationMS) {
-        const { rows } = await this.pool.query(`SELECT output FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs WHERE workflow_uuid=$1 AND function_id=$2`, [workflowUUID, functionID]);
-        if (rows.length > 0) {
-            const endTimeMs = utils_1.DBOSJSON.parse(rows[0].output);
-            return (0, utils_1.cancellableSleep)(Math.max(endTimeMs - Date.now(), 0));
+            endTimeMs = JSON.parse(res.res.res);
         }
         else {
-            const endTimeMs = Date.now() + durationMS;
-            await this.pool.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs (workflow_uuid, function_id, output, function_name) VALUES ($1, $2, $3, $4) ON CONFLICT DO NOTHING;`, [workflowUUID, functionID, utils_1.DBOSJSON.stringify(endTimeMs), 'DBOS.sleep']);
-            return (0, utils_1.cancellableSleep)(Math.max(endTimeMs - Date.now(), 0));
+            await this.recordOperationResult(workflowID, functionID, { serialOutput: JSON.stringify(endTimeMs), functionName: exports.DBOS_FUNCNAME_SLEEP }, false);
         }
+        return (0, utils_1.cancellableSleep)(Math.max(endTimeMs - curTime, 0));
     }
     nullTopic = '__null__topic__';
-    async send(workflowUUID, functionID, destinationUUID, message, topic) {
+    async send(workflowID, functionID, destinationID, message, topic) {
         topic = topic ?? this.nullTopic;
         const client = await this.pool.connect();
         await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
         try {
-            const { rows } = await client.query(`SELECT output FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs WHERE workflow_uuid=$1 AND function_id=$2`, [workflowUUID, functionID]);
-            if (rows.length > 0) {
-                await client.query('ROLLBACK');
-                return;
-            }
-            await client.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.notifications (destination_uuid, topic, message) VALUES ($1, $2, $3);`, [destinationUUID, topic, utils_1.DBOSJSON.stringify(message)]);
-            await this.recordNotificationOutput(client, workflowUUID, functionID, undefined, 'DBOS.send');
-            await client.query('COMMIT');
+            await this.runAsStep(async () => {
+                await client.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.notifications (destination_uuid, topic, message) VALUES ($1, $2, $3);`, [destinationID, topic, message]);
+                await client.query('COMMIT');
+                return undefined;
+            }, exports.DBOS_FUNCNAME_SEND, workflowID, functionID, client);
         }
         catch (error) {
             await client.query('ROLLBACK');
             const err = error;
             if (err.code === '23503') {
                 // Foreign key constraint violation (only expected for the INSERT query)
-                throw new error_1.DBOSNonExistentWorkflowError(`Sent to non-existent destination workflow UUID: ${destinationUUID}`);
+                throw new error_1.DBOSNonExistentWorkflowError(`Sent to non-existent destination workflow UUID: ${destinationID}`);
             }
             else {
                 throw err;
@@ -441,27 +347,30 @@ class PostgresSystemDatabase {
             client.release();
         }
     }
-    async recv(workflowUUID, functionID, timeoutFunctionID, topic, timeoutSeconds = dbos_executor_1.DBOSExecutor.defaultNotificationTimeoutSec) {
+    async recv(workflowID, functionID, timeoutFunctionID, topic, timeoutSeconds = dbos_executor_1.DBOSExecutor.defaultNotificationTimeoutSec) {
         topic = topic ?? this.nullTopic;
         // First, check for previous executions.
-        const checkRows = (await this.pool.query(`SELECT output FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs WHERE workflow_uuid=$1 AND function_id=$2`, [workflowUUID, functionID])).rows;
-        if (checkRows.length > 0) {
-            return utils_1.DBOSJSON.parse(checkRows[0].output);
+        const res = await this.getOperationResult(workflowID, functionID);
+        if (res.res) {
+            if (res.res.functionName !== exports.DBOS_FUNCNAME_RECV) {
+                throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, exports.DBOS_FUNCNAME_RECV, res.res.functionName);
+            }
+            return res.res.res;
         }
         // Check if the key is already in the DB, then wait for the notification if it isn't.
-        const initRecvRows = (await this.pool.query(`SELECT topic FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.notifications WHERE destination_uuid=$1 AND topic=$2;`, [workflowUUID, topic])).rows;
+        const initRecvRows = (await this.pool.query(`SELECT topic FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.notifications WHERE destination_uuid=$1 AND topic=$2;`, [workflowID, topic])).rows;
         if (initRecvRows.length === 0) {
             // Then, register the key with the global notifications listener.
             let resolveNotification;
             const messagePromise = new Promise((resolve) => {
                 resolveNotification = resolve;
             });
-            const payload = `${workflowUUID}::${topic}`;
+            const payload = `${workflowID}::${topic}`;
             this.notificationsMap[payload] = resolveNotification; // The resolver assignment in the Promise definition runs synchronously.
             let timeoutPromise = Promise.resolve();
             let timeoutCancel = () => { };
             try {
-                const { promise, cancel } = await this.durableSleepms(workflowUUID, timeoutFunctionID, timeoutSeconds * 1000);
+                const { promise, cancel } = await this.durableSleepms(workflowID, timeoutFunctionID, timeoutSeconds * 1000);
                 timeoutPromise = promise;
                 timeoutCancel = cancel;
             }
@@ -498,11 +407,11 @@ class PostgresSystemDatabase {
         WHERE notifications.destination_uuid = oldest_entry.destination_uuid
           AND notifications.topic = oldest_entry.topic
           AND notifications.created_at_epoch_ms = oldest_entry.created_at_epoch_ms
-        RETURNING notifications.*;`, [workflowUUID, topic])).rows;
+        RETURNING notifications.*;`, [workflowID, topic])).rows;
             if (finalRecvRows.length > 0) {
-                message = utils_1.DBOSJSON.parse(finalRecvRows[0].message);
+                message = finalRecvRows[0].message;
             }
-            await this.recordNotificationOutput(client, workflowUUID, functionID, message, 'DBOS.recv');
+            await this.recordOperationResult(workflowID, functionID, { serialOutput: message, functionName: exports.DBOS_FUNCNAME_RECV }, true, client);
             await client.query(`COMMIT`);
         }
         catch (e) {
@@ -515,22 +424,19 @@ class PostgresSystemDatabase {
         }
         return message;
     }
-    async setEvent(workflowUUID, functionID, key, message) {
+    async setEvent(workflowID, functionID, key, message) {
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
-            let { rows } = await client.query(`SELECT output FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs WHERE workflow_uuid=$1 AND function_id=$2`, [workflowUUID, functionID]);
-            if (rows.length > 0) {
-                await client.query('ROLLBACK');
-                return;
-            }
-            ({ rows } = await client.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_events (workflow_uuid, key, value)
-         VALUES ($1, $2, $3)
-         ON CONFLICT (workflow_uuid, key)
-         DO UPDATE SET value = $3
-         RETURNING workflow_uuid;`, [workflowUUID, key, utils_1.DBOSJSON.stringify(message)]));
-            await this.recordNotificationOutput(client, workflowUUID, functionID, undefined, 'DBOS.setEvent');
-            await client.query('COMMIT');
+            await this.runAsStep(async () => {
+                await client.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_events (workflow_uuid, key, value)
+             VALUES ($1, $2, $3)
+             ON CONFLICT (workflow_uuid, key)
+             DO UPDATE SET value = $3
+             RETURNING workflow_uuid;`, [workflowID, key, message]);
+                await client.query('COMMIT');
+                return undefined;
+            }, exports.DBOS_FUNCNAME_SETEVENT, workflowID, functionID, client);
         }
         catch (e) {
             this.logger.error(e);
@@ -541,20 +447,20 @@ class PostgresSystemDatabase {
             client.release();
         }
     }
-    async getEvent(workflowUUID, key, timeoutSeconds, callerWorkflow) {
+    async getEvent(workflowID, key, timeoutSeconds, callerWorkflow) {
         // Check if the operation has been done before for OAOO (only do this inside a workflow).
         if (callerWorkflow) {
-            const { rows } = await this.pool.query(`
-        SELECT output
-        FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs
-        WHERE workflow_uuid=$1 AND function_id=$2`, [callerWorkflow.workflowUUID, callerWorkflow.functionID]);
-            if (rows.length > 0) {
-                return utils_1.DBOSJSON.parse(rows[0].output);
+            const res = await this.getOperationResult(callerWorkflow.workflowID, callerWorkflow.functionID);
+            if (res.res !== undefined) {
+                if (res.res.functionName !== exports.DBOS_FUNCNAME_GETEVENT) {
+                    throw new error_1.DBOSUnexpectedStepError(callerWorkflow.workflowID, callerWorkflow.functionID, exports.DBOS_FUNCNAME_GETEVENT, res.res.functionName);
+                }
+                return res.res.res;
             }
         }
         // Get the return the value. if it's in the DB, otherwise return null.
         let value = null;
-        const payloadKey = `${workflowUUID}::${key}`;
+        const payloadKey = `${workflowID}::${key}`;
         // Register the key with the global notifications listener first... we do not want to look in the DB first
         //  or that would cause a timing hole.
         let resolveNotification;
@@ -567,9 +473,9 @@ class PostgresSystemDatabase {
             const initRecvRows = (await this.pool.query(`
         SELECT key, value
         FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_events
-        WHERE workflow_uuid=$1 AND key=$2;`, [workflowUUID, key])).rows;
+        WHERE workflow_uuid=$1 AND key=$2;`, [workflowID, key])).rows;
             if (initRecvRows.length > 0) {
-                value = utils_1.DBOSJSON.parse(initRecvRows[0].value);
+                value = initRecvRows[0].value;
             }
             else {
                 // If we have a callerWorkflow, we want a durable sleep, otherwise, not
@@ -577,7 +483,7 @@ class PostgresSystemDatabase {
                 let timeoutCancel = () => { };
                 if (callerWorkflow) {
                     try {
-                        const { promise, cancel } = await this.durableSleepms(callerWorkflow.workflowUUID, callerWorkflow.timeoutFunctionID ?? -1, timeoutSeconds * 1000);
+                        const { promise, cancel } = await this.durableSleepms(callerWorkflow.workflowID, callerWorkflow.timeoutFunctionID ?? -1, timeoutSeconds * 1000);
                         timeoutPromise = promise;
                         timeoutCancel = cancel;
                     }
@@ -601,9 +507,9 @@ class PostgresSystemDatabase {
                 const finalRecvRows = (await this.pool.query(`
             SELECT value
             FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_events
-            WHERE workflow_uuid=$1 AND key=$2;`, [workflowUUID, key])).rows;
+            WHERE workflow_uuid=$1 AND key=$2;`, [workflowID, key])).rows;
                 if (finalRecvRows.length > 0) {
-                    value = utils_1.DBOSJSON.parse(finalRecvRows[0].value);
+                    value = finalRecvRows[0].value;
                 }
             }
         }
@@ -612,26 +518,25 @@ class PostgresSystemDatabase {
         }
         // Record the output if it is inside a workflow.
         if (callerWorkflow) {
-            await this.recordOperationOutput(callerWorkflow.workflowUUID, callerWorkflow.functionID, value, 'DBOS.getEvent');
+            await this.recordOperationResult(callerWorkflow.workflowID, callerWorkflow.functionID, {
+                serialOutput: value,
+                functionName: exports.DBOS_FUNCNAME_GETEVENT,
+            }, true);
         }
         return value;
     }
-    async setWorkflowStatus(workflowUUID, status, resetRecoveryAttempts) {
-        await this.pool.query(`UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status SET status=$1 WHERE workflow_uuid=$2`, [status, workflowUUID]);
-        if (resetRecoveryAttempts) {
-            await this.pool.query(`UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status SET recovery_attempts=0 WHERE workflow_uuid=$1`, [workflowUUID]);
-        }
+    async setWorkflowStatus(workflowID, status, resetRecoveryAttempts) {
+        await this.recordWorkflowStatusChange(workflowID, status, { resetRecoveryAttempts });
     }
-    async cancelWorkflow(workflowUUID) {
+    async cancelWorkflow(workflowID) {
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN');
             // Remove workflow from queues table
             await client.query(`DELETE FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue 
-         WHERE workflow_uuid = $1`, [workflowUUID]);
-            await client.query(`UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status 
-         SET status = $1 
-         WHERE workflow_uuid = $2`, [workflow_1.StatusString.CANCELLED, workflowUUID]);
+         WHERE workflow_uuid = $1`, [workflowID]);
+            // Should we check if it is incomplete first?
+            await this.recordWorkflowStatusChange(workflowID, workflow_1.StatusString.CANCELLED, {}, client);
             await client.query('COMMIT');
         }
         catch (error) {
@@ -642,13 +547,13 @@ class PostgresSystemDatabase {
             client.release();
         }
     }
-    async resumeWorkflow(workflowUUID) {
+    async resumeWorkflow(workflowID) {
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN');
             // Check workflow status. If it is complete, do nothing.
             const statusResult = await client.query(`SELECT status FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status 
-         WHERE workflow_uuid = $1`, [workflowUUID]);
+         WHERE workflow_uuid = $1`, [workflowID]);
             if (statusResult.rows.length === 0 ||
                 statusResult.rows[0].status === workflow_1.StatusString.SUCCESS ||
                 statusResult.rows[0].status === workflow_1.StatusString.ERROR) {
@@ -657,11 +562,9 @@ class PostgresSystemDatabase {
             }
             // Remove the workflow from the queues table so resume can safely be called on an ENQUEUED workflow
             await client.query(`DELETE FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue 
-         WHERE workflow_uuid = $1`, [workflowUUID]);
+         WHERE workflow_uuid = $1`, [workflowID]);
             // Update status to pending and reset recovery attempts
-            await client.query(`UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status 
-         SET status = $1, recovery_attempts = 0 
-         WHERE workflow_uuid = $2`, [workflow_1.StatusString.PENDING, workflowUUID]);
+            await this.recordWorkflowStatusChange(workflowID, workflow_1.StatusString.PENDING, { resetRecoveryAttempts: true }, client);
             await client.query('COMMIT');
         }
         catch (error) {
@@ -672,8 +575,8 @@ class PostgresSystemDatabase {
             client.release();
         }
     }
-    async getWorkflowStatus(workflowUUID, callerUUID) {
-        const internalStatus = await this.getWorkflowStatusInternal(workflowUUID, callerUUID);
+    async getWorkflowStatus(workflowID, callerID, callerFN) {
+        const internalStatus = await this.getWorkflowStatusInternal(workflowID, callerID, callerFN);
         if (internalStatus === null) {
             return null;
         }
@@ -690,63 +593,66 @@ class PostgresSystemDatabase {
             executorId: internalStatus.executorId,
         };
     }
-    async getWorkflowStatusInternal(workflowUUID, callerUUID) {
+    async getWorkflowStatusInternal(workflowID, callerID, callerFN) {
         // Check if the operation has been done before for OAOO (only do this inside a workflow).
-        const wfctx = (0, context_2.getCurrentDBOSContext)();
-        let newfunctionId = undefined;
-        if (callerUUID !== undefined && wfctx !== undefined) {
-            newfunctionId = wfctx.functionIDGetIncrement();
-            const { rows } = await this.pool.query(`SELECT output FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs WHERE workflow_uuid=$1 AND function_id=$2 AND function_name=$3`, [callerUUID, newfunctionId, 'getStatus']);
+        const sv = await this.runAsStep(async () => {
+            const { rows } = await this.pool.query(`SELECT workflow_uuid, status, name, class_name, config_name, authenticated_user, assumed_role, authenticated_roles, request, queue_name, executor_id, created_at, updated_at, application_version, application_id, recovery_attempts FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status WHERE workflow_uuid=$1`, [workflowID]);
+            let value = null;
             if (rows.length > 0) {
-                return utils_1.DBOSJSON.parse(rows[0].output);
-            }
-        }
-        const { rows } = await this.pool.query(`SELECT workflow_uuid, status, name, class_name, config_name, authenticated_user, assumed_role, authenticated_roles, request, queue_name, executor_id, created_at, updated_at, application_version, application_id, recovery_attempts FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status WHERE workflow_uuid=$1`, [workflowUUID]);
-        let value = null;
-        if (rows.length > 0) {
-            value = {
-                workflowUUID: rows[0].workflow_uuid,
-                status: rows[0].status,
-                workflowName: rows[0].name,
-                output: undefined,
-                error: '',
-                workflowClassName: rows[0].class_name || '',
-                workflowConfigName: rows[0].config_name || '',
-                queueName: rows[0].queue_name || undefined,
-                authenticatedUser: rows[0].authenticated_user,
-                assumedRole: rows[0].assumed_role,
-                authenticatedRoles: utils_1.DBOSJSON.parse(rows[0].authenticated_roles),
-                request: utils_1.DBOSJSON.parse(rows[0].request),
-                executorId: rows[0].executor_id,
-                createdAt: Number(rows[0].created_at),
-                updatedAt: Number(rows[0].updated_at),
-                applicationVersion: rows[0].application_version,
-                applicationID: rows[0].application_id,
-                recoveryAttempts: Number(rows[0].recovery_attempts),
-                maxRetries: 0,
-            };
-        }
-        // Record the output if it is inside a workflow.
-        if (callerUUID !== undefined && newfunctionId !== undefined) {
-            await this.recordOperationOutput(callerUUID, newfunctionId, value, 'getStatus');
-        }
-        return value;
-    }
-    async getWorkflowResult(workflowUUID) {
+                value = {
+                    workflowUUID: rows[0].workflow_uuid,
+                    status: rows[0].status,
+                    workflowName: rows[0].name,
+                    output: null,
+                    error: null,
+                    workflowClassName: rows[0].class_name || '',
+                    workflowConfigName: rows[0].config_name || '',
+                    queueName: rows[0].queue_name || undefined,
+                    authenticatedUser: rows[0].authenticated_user,
+                    assumedRole: rows[0].assumed_role,
+                    authenticatedRoles: utils_1.DBOSJSON.parse(rows[0].authenticated_roles),
+                    request: utils_1.DBOSJSON.parse(rows[0].request),
+                    executorId: rows[0].executor_id,
+                    createdAt: Number(rows[0].created_at),
+                    updatedAt: Number(rows[0].updated_at),
+                    applicationVersion: rows[0].application_version,
+                    applicationID: rows[0].application_id,
+                    recoveryAttempts: Number(rows[0].recovery_attempts),
+                    maxRetries: 0,
+                };
+            }
+            return value ? JSON.stringify(value) : null;
+        }, exports.DBOS_FUNCNAME_GETSTATUS, callerID, callerFN);
+        return sv ? JSON.parse(sv) : null;
+    }
+    async awaitWorkflowResult(workflowID, timeoutms) {
         const pollingIntervalMs = 1000;
+        const et = timeoutms !== undefined ? new Date().getTime() + timeoutms : undefined;
         while (true) {
-            const { rows } = await this.pool.query(`SELECT status, output, error FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status WHERE workflow_uuid=$1`, [workflowUUID]);
+            const { rows } = await this.pool.query(`SELECT status, output, error FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status WHERE workflow_uuid=$1`, [workflowID]);
             if (rows.length > 0) {
                 const status = rows[0].status;
                 if (status === workflow_1.StatusString.SUCCESS) {
-                    return utils_1.DBOSJSON.parse(rows[0].output);
+                    return { res: rows[0].output };
                 }
                 else if (status === workflow_1.StatusString.ERROR) {
-                    throw (0, serialize_error_1.deserializeError)(utils_1.DBOSJSON.parse(rows[0].error));
+                    return { err: rows[0].error };
+                }
+            }
+            if (et !== undefined) {
+                const ct = new Date().getTime();
+                if (et > ct) {
+                    await (0, utils_1.sleepms)(Math.min(pollingIntervalMs, et - ct));
+                }
+                else {
+                    break;
                 }
             }
-            await (0, utils_1.sleepms)(pollingIntervalMs);
+            else {
+                await (0, utils_1.sleepms)(pollingIntervalMs);
+            }
         }
+        return undefined;
     }
     /* BACKGROUND PROCESSES */
     /**
@@ -948,14 +854,7 @@ class PostgresSystemDatabase {
                 return false;
             }
             // Reset the status of the task to "ENQUEUED"
-            const wsRes = await client.query(`
-        UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status
-        SET status = $2
-        WHERE workflow_uuid = $1;
-      `, [workflowId, workflow_1.StatusString.ENQUEUED]);
-            if (wsRes.rowCount === 0) {
-                throw new Error(`UNREACHABLE: Workflow ${workflowId} is found in the workflow_queue table but not found in the workflow_status table`);
-            }
+            await this.recordWorkflowStatusChange(workflowId, workflow_1.StatusString.ENQUEUED, {}, client);
             await client.query('COMMIT');
             return true;
         }