@dbos-inc/dbos-sdk 2.8.46-preview.g30b0e27ed1 → 2.9.9-preview

package/dist/src/system_database.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -39,37 +40,6 @@ async function migrateSystemDatabase(systemPoolConfig, logger) {
     }
 }
 exports.migrateSystemDatabase = migrateSystemDatabase;
-class NotificationMap {
-    map = new Map();
-    curCK = 0;
-    registerCallback(key, cb) {
-        if (!this.map.has(key)) {
-            this.map.set(key, new Map());
-        }
-        const ck = this.curCK++;
-        this.map.get(key).set(ck, cb);
-        return { key, ck };
-    }
-    deregisterCallback(k) {
-        if (!this.map.has(k.key))
-            return;
-        const sm = this.map.get(k.key);
-        if (!sm.has(k.ck))
-            return;
-        sm.delete(k.ck);
-        if (sm.size === 0) {
-            this.map.delete(k.key);
-        }
-    }
-    callCallbacks(key, event) {
-        if (!this.map.has(key))
-            return;
-        const sm = this.map.get(key);
-        for (const cb of sm.values()) {
-            cb(event);
-        }
-    }
-}
 class PostgresSystemDatabase {
     pgPoolConfig;
     systemDatabaseName;
@@ -78,32 +48,9 @@ class PostgresSystemDatabase {
     pool;
     systemPoolConfig;
     knexDB;
-    /*
-     * Generally, notifications are asynchronous.  One should:
-     *  Subscribe to updates
-     *  Read the database item in question
-     *  In response to updates, re-read the database item
-     *  Unsubscribe at the end
-     * The notification mechanism is reliable in the sense that it will eventually deliver updates
-     *  or the DB connection will get dropped.  The right thing to do if you lose connectivity to
-     *  the system DB is to exit the process and go through recovery... system DB writes, notifications,
-     *  etc may not have completed correctly, and recovery is the way to rebuild in-memory state.
-     *
-     * NOTE:
-     * PG Notifications are not fully reliable.
-     *   Dropped connections are recoverable - you just need to restart and scan everything.
-     *      (The whole VM being the logical choice, so workflows can recover from any write failures.)
-     *   The real problem is, if the pipes out of the server are full... then notifications can be
-     *     dropped, and only the PG server log may note it.  For those reasons, we do occasional polling
-     */
     notificationsClient = null;
-    dbPollingIntervalMs = 1000;
-    shouldUseDBNotifications = true;
-    notificationsMap = new NotificationMap();
-    workflowEventsMap = new NotificationMap();
-    cancelWakeupMap = new NotificationMap();
-    runningWorkflowMap = new Map(); // Map from workflowID to workflow promise
-    workflowCancellationMap = new Map(); // Map from workflowID to its cancellation status.
+    notificationsMap = {};
+    workflowEventsMap = {};
     constructor(pgPoolConfig, systemDatabaseName, logger, sysDbPoolSize) {
         this.pgPoolConfig = pgPoolConfig;
         this.systemDatabaseName = systemDatabaseName;
@@ -153,9 +100,7 @@ class PostgresSystemDatabase {
         finally {
             await pgSystemClient.end();
         }
-        if (this.shouldUseDBNotifications) {
-            await this.listenForNotifications();
-        }
+        await this.listenForNotifications();
     }
     async destroy() {
         await this.knexDB.destroy();
@@ -178,7 +123,7 @@ class PostgresSystemDatabase {
         await pgSystemClient.query(`DROP DATABASE IF EXISTS ${dbosConfig.system_database};`);
         await pgSystemClient.end();
     }
-    async initWorkflowStatus(initStatus, serializedInputs) {
+    async initWorkflowStatus(initStatus, args, maxRetries) {
         const result = await this.pool.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status (
         workflow_uuid,
         status,
@@ -190,14 +135,13 @@ class PostgresSystemDatabase {
         assumed_role,
         authenticated_roles,
         request,
-        output,
         executor_id,
         application_version,
         application_id,
         created_at,
         recovery_attempts,
         updated_at
-      ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)
+      ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
        ON CONFLICT (workflow_uuid)
         DO UPDATE SET
           recovery_attempts = workflow_status.recovery_attempts + 1,
@@ -212,9 +156,8 @@ class PostgresSystemDatabase {
             initStatus.queueName,
             initStatus.authenticatedUser,
             initStatus.assumedRole,
-            JSON.stringify(initStatus.authenticatedRoles),
-            JSON.stringify(initStatus.request),
-            null,
+            utils_1.DBOSJSON.stringify(initStatus.authenticatedRoles),
+            utils_1.DBOSJSON.stringify(initStatus.request),
             initStatus.executorId,
             initStatus.applicationVersion,
             initStatus.applicationID,
@@ -249,17 +192,18 @@ class PostgresSystemDatabase {
         // Every time we init the status, we increment `recovery_attempts` by 1.
         // Thus, when this number becomes equal to `maxRetries + 1`, we should mark the workflow as `RETRIES_EXCEEDED`.
         const attempts = resRow.recovery_attempts;
-        if (attempts > initStatus.maxRetries + 1) {
+        if (maxRetries && attempts > maxRetries + 1) {
             await this.pool.query(`UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status SET status=$1 WHERE workflow_uuid=$2 AND status=$3`, [workflow_1.StatusString.RETRIES_EXCEEDED, initStatus.workflowUUID, workflow_1.StatusString.PENDING]);
-            throw new error_1.DBOSDeadLetterQueueError(initStatus.workflowUUID, initStatus.maxRetries);
+            throw new error_1.DBOSDeadLetterQueueError(initStatus.workflowUUID, maxRetries);
         }
         this.logger.debug(`Workflow ${initStatus.workflowUUID} attempt number: ${attempts}.`);
         const status = resRow.status;
+        const serializedInputs = utils_1.DBOSJSON.stringify(args);
         const { rows } = await this.pool.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_inputs (workflow_uuid, inputs) VALUES($1, $2) ON CONFLICT (workflow_uuid) DO UPDATE SET workflow_uuid = excluded.workflow_uuid  RETURNING inputs`, [initStatus.workflowUUID, serializedInputs]);
         if (serializedInputs !== rows[0].inputs) {
             this.logger.warn(`Workflow inputs for ${initStatus.workflowUUID} changed since the first call! Use the original inputs.`);
         }
-        return { serializedInputs: rows[0].inputs, status };
+        return { args: utils_1.DBOSJSON.parse(rows[0].inputs), status };
     }
     async recordWorkflowStatusChange(workflowID, status, update, client) {
         let rec = '';
@@ -272,7 +216,7 @@ class PostgresSystemDatabase {
         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.DBOSWorkflowConflictError(`Attempt to record transition of nonexistent workflow ${workflowID}`);
+            throw new error_1.DBOSWorkflowConflictUUIDError(`Attempt to record transition of nonexistent workflow ${workflowID}`);
         }
     }
     async recordWorkflowOutput(workflowID, status) {
@@ -293,10 +237,9 @@ class PostgresSystemDatabase {
         if (rows.length === 0) {
             return null;
         }
-        return rows[0].inputs;
+        return utils_1.DBOSJSON.parse(rows[0].inputs);
     }
     async getOperationResult(workflowID, functionID, client) {
-        await this.checkIfCanceled(workflowID);
         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]);
@@ -337,13 +280,110 @@ class PostgresSystemDatabase {
             const err = error;
             if (err.code === '40001' || err.code === '23505') {
                 // Serialization and primary key conflict (Postgres).
-                throw new error_1.DBOSWorkflowConflictError(workflowID);
+                throw new error_1.DBOSWorkflowConflictUUIDError(workflowID);
             }
             else {
                 throw err;
             }
         }
     }
+    async getMaxFunctionID(workflowID) {
+        const { rows } = await this.pool.query(`SELECT max(function_id) as max_function_id FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs WHERE workflow_uuid=$1`, [workflowID]);
+        return rows.length === 0 ? 0 : rows[0].max_function_id;
+    }
+    async forkWorkflow(originalWorkflowID, forkedWorkflowId, startStep = 0) {
+        const workflowStatus = await this.getWorkflowStatus(originalWorkflowID);
+        if (workflowStatus === null) {
+            throw new error_1.DBOSNonExistentWorkflowError(`Workflow ${originalWorkflowID} does not exist`);
+        }
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            const 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_version,
+        application_id,
+        created_at,
+        recovery_attempts,
+        updated_at
+      ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)
+        `;
+            await client.query(query, [
+                forkedWorkflowId,
+                workflow_1.StatusString.ENQUEUED,
+                workflowStatus.workflowName,
+                workflowStatus.workflowClassName,
+                workflowStatus.workflowConfigName,
+                utils_1.INTERNAL_QUEUE_NAME,
+                workflowStatus.authenticatedUser,
+                workflowStatus.assumedRole,
+                utils_1.DBOSJSON.stringify(workflowStatus.authenticatedRoles),
+                utils_1.DBOSJSON.stringify(workflowStatus.request),
+                null,
+                null,
+                workflowStatus.applicationVersion,
+                workflowStatus.applicationID,
+                Date.now(),
+                0,
+                Date.now(),
+            ]);
+            // Copy the inputs to the new workflow
+            const inputQuery = `INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_inputs (workflow_uuid, inputs)
+                            SELECT $2, inputs
+                            FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_inputs
+                            WHERE workflow_uuid = $1;`;
+            await client.query(inputQuery, [originalWorkflowID, forkedWorkflowId]);
+            if (startStep > 0) {
+                const query = `
+          INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs (
+          workflow_uuid,
+          function_id,
+          output,
+          error,
+          function_name,
+          child_workflow_id
+        )
+        SELECT
+          $1 AS workflow_uuid,
+          function_id,
+          output,
+          error,
+          function_name,
+          child_workflow_id
+          FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs
+          WHERE workflow_uuid = $2 AND function_id < $3
+        `;
+                await client.query(query, [forkedWorkflowId, originalWorkflowID, startStep]);
+            }
+            await client.query(`
+      INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue (workflow_uuid, queue_name)
+      VALUES ($1, $2)
+      ON CONFLICT (workflow_uuid)
+      DO NOTHING;
+      `, [forkedWorkflowId, utils_1.INTERNAL_QUEUE_NAME]);
+            await client.query('COMMIT');
+            return forkedWorkflowId;
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
     async runAsStep(callback, functionName, workflowID, functionID, client) {
         if (workflowID !== undefined && functionID !== undefined) {
             const res = await this.getOperationResult(workflowID, functionID, client);
@@ -362,30 +402,6 @@ class PostgresSystemDatabase {
         return serialOutput;
     }
     async durableSleepms(workflowID, functionID, durationMS) {
-        let resolveNotification;
-        const cancelPromise = new Promise((resolve) => {
-            resolveNotification = resolve;
-        });
-        const cbr = this.cancelWakeupMap.registerCallback(workflowID, resolveNotification);
-        try {
-            let timeoutPromise = Promise.resolve();
-            const { promise, cancel: timeoutCancel } = await this.durableSleepmsInternal(workflowID, functionID, durationMS);
-            timeoutPromise = promise;
-            try {
-                await Promise.race([cancelPromise, timeoutPromise]);
-            }
-            finally {
-                timeoutCancel();
-            }
-        }
-        finally {
-            this.cancelWakeupMap.deregisterCallback(cbr);
-        }
-        await this.checkIfCanceled(workflowID);
-    }
-    async durableSleepmsInternal(workflowID, functionID, durationMS, maxSleepPerIteration) {
-        if (maxSleepPerIteration === undefined)
-            maxSleepPerIteration = durationMS;
         const curTime = Date.now();
         let endTimeMs = curTime + durationMS;
         const res = await this.getOperationResult(workflowID, functionID);
@@ -398,10 +414,7 @@ class PostgresSystemDatabase {
         else {
             await this.recordOperationResult(workflowID, functionID, { serialOutput: JSON.stringify(endTimeMs), functionName: exports.DBOS_FUNCNAME_SLEEP }, false);
         }
-        return {
-            ...(0, utils_1.cancellableSleep)(Math.max(Math.min(maxSleepPerIteration, endTimeMs - curTime), 0)),
-            endTime: endTimeMs,
-        };
+        return (0, utils_1.cancellableSleep)(Math.max(endTimeMs - curTime, 0));
     }
     nullTopic = '__null__topic__';
     async send(workflowID, functionID, destinationID, message, topic) {
@@ -440,56 +453,37 @@ class PostgresSystemDatabase {
             }
             return res.res.res;
         }
-        const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
-        let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
-        while (true) {
-            // register the key with the global notifications listener.
+        // 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;`, [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 = `${workflowID}::${topic}`;
-            const cbr = this.notificationsMap.registerCallback(payload, resolveNotification);
-            const crh = this.cancelWakeupMap.registerCallback(workflowID, (_res) => {
-                resolveNotification();
-            });
+            this.notificationsMap[payload] = resolveNotification; // The resolver assignment in the Promise definition runs synchronously.
+            let timeoutPromise = Promise.resolve();
+            let timeoutCancel = () => { };
             try {
-                await this.checkIfCanceled(workflowID);
-                // 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;`, [workflowID, topic])).rows;
-                if (initRecvRows.length !== 0)
-                    break;
-                const ct = Date.now();
-                if (finishTime && ct > finishTime)
-                    break; // Time's up
-                let timeoutPromise = Promise.resolve();
-                let timeoutCancel = () => { };
-                if (timeoutms) {
-                    const { promise, cancel, endTime } = await this.durableSleepmsInternal(workflowID, timeoutFunctionID, timeoutms, this.dbPollingIntervalMs);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                    finishTime = endTime;
-                }
-                else {
-                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalMs;
-                    poll = Math.min(this.dbPollingIntervalMs, poll);
-                    const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                }
-                try {
-                    await Promise.race([messagePromise, timeoutPromise]);
-                }
-                finally {
-                    timeoutCancel();
-                }
+                const { promise, cancel } = await this.durableSleepms(workflowID, timeoutFunctionID, timeoutSeconds * 1000);
+                timeoutPromise = promise;
+                timeoutCancel = cancel;
+            }
+            catch (e) {
+                this.logger.error(e);
+                delete this.notificationsMap[payload];
+                timeoutCancel();
+                throw new Error('durable sleepms failed');
+            }
+            try {
+                await Promise.race([messagePromise, timeoutPromise]);
             }
             finally {
-                this.notificationsMap.deregisterCallback(cbr);
-                this.cancelWakeupMap.deregisterCallback(crh);
+                timeoutCancel();
+                delete this.notificationsMap[payload];
             }
         }
-        await this.checkIfCanceled(workflowID);
         // Transactionally consume and return the message if it's in the DB, otherwise return null.
         let message = null;
         const client = await this.pool.connect();
@@ -563,49 +557,40 @@ class PostgresSystemDatabase {
         // Get the return the value. if it's in the DB, otherwise return null.
         let value = null;
         const payloadKey = `${workflowID}::${key}`;
-        const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
-        let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
         // 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.
-        while (true) {
-            let resolveNotification;
-            const valuePromise = new Promise((resolve) => {
-                resolveNotification = resolve;
-            });
-            const cbr = this.workflowEventsMap.registerCallback(payloadKey, resolveNotification);
-            const crh = callerWorkflow?.workflowID
-                ? this.cancelWakeupMap.registerCallback(callerWorkflow.workflowID, (_res) => {
-                    resolveNotification();
-                })
-                : undefined;
-            try {
-                if (callerWorkflow?.workflowID)
-                    await this.checkIfCanceled(callerWorkflow?.workflowID);
-                // 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 key, value
-          FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_events
-          WHERE workflow_uuid=$1 AND key=$2;`, [workflowID, key])).rows;
-                if (initRecvRows.length > 0) {
-                    value = initRecvRows[0].value;
-                    break;
-                }
-                const ct = Date.now();
-                if (finishTime && ct > finishTime)
-                    break; // Time's up
+        let resolveNotification;
+        const valuePromise = new Promise((resolve) => {
+            resolveNotification = resolve;
+        });
+        this.workflowEventsMap[payloadKey] = resolveNotification; // The resolver assignment in the Promise definition runs synchronously.
+        try {
+            // 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 key, value
+        FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_events
+        WHERE workflow_uuid=$1 AND key=$2;`, [workflowID, key])).rows;
+            if (initRecvRows.length > 0) {
+                value = initRecvRows[0].value;
+            }
+            else {
                 // If we have a callerWorkflow, we want a durable sleep, otherwise, not
                 let timeoutPromise = Promise.resolve();
                 let timeoutCancel = () => { };
-                if (callerWorkflow && timeoutms) {
-                    const { promise, cancel, endTime } = await this.durableSleepmsInternal(callerWorkflow.workflowID, callerWorkflow.timeoutFunctionID ?? -1, timeoutms, this.dbPollingIntervalMs);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                    finishTime = endTime;
+                if (callerWorkflow) {
+                    try {
+                        const { promise, cancel } = await this.durableSleepms(callerWorkflow.workflowID, callerWorkflow.timeoutFunctionID ?? -1, timeoutSeconds * 1000);
+                        timeoutPromise = promise;
+                        timeoutCancel = cancel;
+                    }
+                    catch (e) {
+                        this.logger.error(e);
+                        delete this.workflowEventsMap[payloadKey];
+                        throw new Error('durable sleepms failed');
+                    }
                 }
                 else {
-                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalMs;
-                    poll = Math.min(this.dbPollingIntervalMs, poll);
-                    const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
+                    const { promise, cancel } = (0, utils_1.cancellableSleep)(timeoutSeconds * 1000);
                     timeoutPromise = promise;
                     timeoutCancel = cancel;
                 }
@@ -615,12 +600,17 @@ class PostgresSystemDatabase {
                 finally {
                     timeoutCancel();
                 }
+                const finalRecvRows = (await this.pool.query(`
+            SELECT value
+            FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_events
+            WHERE workflow_uuid=$1 AND key=$2;`, [workflowID, key])).rows;
+                if (finalRecvRows.length > 0) {
+                    value = finalRecvRows[0].value;
+                }
             }
-            finally {
-                this.workflowEventsMap.deregisterCallback(cbr);
-                if (crh)
-                    this.cancelWakeupMap.deregisterCallback(crh);
-            }
+        }
+        finally {
+            delete this.workflowEventsMap[payloadKey];
         }
         // Record the output if it is inside a workflow.
         if (callerWorkflow) {
@@ -634,23 +624,10 @@ class PostgresSystemDatabase {
     async setWorkflowStatus(workflowID, status, resetRecoveryAttempts) {
         await this.recordWorkflowStatusChange(workflowID, status, { resetRecoveryAttempts });
     }
-    setWFCancelMap(workflowID) {
-        if (this.runningWorkflowMap.has(workflowID)) {
-            this.workflowCancellationMap.set(workflowID, true);
-        }
-        this.cancelWakeupMap.callCallbacks(workflowID);
-    }
-    clearWFCancelMap(workflowID) {
-        if (this.workflowCancellationMap.has(workflowID)) {
-            this.workflowCancellationMap.delete(workflowID);
-        }
-    }
     async cancelWorkflow(workflowID) {
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN');
-            await client.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_cancel(workflow_id)
-         VALUES ($1)`, [workflowID]);
             // Remove workflow from queues table
             await client.query(`DELETE FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue 
          WHERE workflow_uuid = $1`, [workflowID]);
@@ -659,25 +636,18 @@ class PostgresSystemDatabase {
             await client.query('COMMIT');
         }
         catch (error) {
-            this.logger.error(error);
             await client.query('ROLLBACK');
             throw error;
         }
         finally {
             client.release();
         }
-        this.setWFCancelMap(workflowID);
-    }
-    async checkIfCanceled(workflowID) {
-        if (this.workflowCancellationMap.get(workflowID) === true) {
-            throw new error_1.DBOSWorkflowCancelledError(workflowID);
-        }
-        return Promise.resolve();
     }
     async resumeWorkflow(workflowID) {
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN');
+            await client.query('SET TRANSACTION ISOLATION LEVEL REPEATABLE READ');
             // 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`, [workflowID]);
@@ -690,172 +660,62 @@ 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`, [workflowID]);
-            await client.query(`DELETE FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_cancel 
-         WHERE workflow_id = $1`, [workflowID]);
-            // Update status to pending and reset recovery attempts
-            await this.recordWorkflowStatusChange(workflowID, workflow_1.StatusString.PENDING, { resetRecoveryAttempts: true }, client);
+            await client.query(`UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status 
+         SET status = $1, queue_name= $2, recovery_attempts = 0 
+         WHERE workflow_uuid = $3`, [workflow_1.StatusString.ENQUEUED, utils_1.INTERNAL_QUEUE_NAME, workflowID]);
+            await client.query(`
+        INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue (workflow_uuid, queue_name)
+        VALUES ($1, $2)
+        ON CONFLICT (workflow_uuid)
+        DO NOTHING;
+      `, [workflowID, utils_1.INTERNAL_QUEUE_NAME]);
             await client.query('COMMIT');
         }
         catch (error) {
-            this.logger.error(error);
             await client.query('ROLLBACK');
             throw error;
         }
         finally {
             client.release();
         }
-        this.clearWFCancelMap(workflowID);
-    }
-    registerRunningWorkflow(workflowID, workflowPromise) {
-        // 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.runningWorkflowMap.delete(workflowID);
-            this.workflowCancellationMap.delete(workflowID);
-        });
-        this.runningWorkflowMap.set(workflowID, awaitWorkflowPromise);
-    }
-    async awaitRunningWorkflows() {
-        if (this.runningWorkflowMap.size > 0) {
-            this.logger.info('Waiting for pending workflows to finish.');
-            await Promise.allSettled(this.runningWorkflowMap.values());
-        }
-        if (this.workflowEventsMap.map.size > 0) {
-            this.logger.warn('Workflow events map is not empty - shutdown is not clean.');
-            //throw new Error('Workflow events map is not empty - shutdown is not clean.');
-        }
-        if (this.notificationsMap.map.size > 0) {
-            this.logger.warn('Message notification map is not empty - shutdown is not clean.');
-            //throw new Error('Message notification map is not empty - shutdown is not clean.');
-        }
     }
     async getWorkflowStatus(workflowID, callerID, callerFN) {
-        const internalStatus = await this.getWorkflowStatusInternal(workflowID, callerID, callerFN);
-        if (internalStatus === null) {
-            return null;
-        }
-        return {
-            status: internalStatus.status,
-            workflowName: internalStatus.workflowName,
-            workflowClassName: internalStatus.workflowClassName,
-            workflowConfigName: internalStatus.workflowConfigName,
-            queueName: internalStatus.queueName,
-            authenticatedUser: internalStatus.authenticatedUser,
-            assumedRole: internalStatus.assumedRole,
-            authenticatedRoles: internalStatus.authenticatedRoles,
-            request: internalStatus.request,
-            executorId: internalStatus.executorId,
-        };
-    }
-    async getWorkflowStatusInternal(workflowID, callerID, callerFN) {
         // Check if the operation has been done before for OAOO (only do this inside a workflow).
         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) {
-                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: JSON.parse(rows[0].authenticated_roles),
-                    request: JSON.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;
+            const statuses = await this.listWorkflows({ workflowIDs: [workflowID] });
+            const status = statuses.find((s) => s.workflowUUID === workflowID);
+            return status ? JSON.stringify(status) : null;
         }, exports.DBOS_FUNCNAME_GETSTATUS, callerID, callerFN);
         return sv ? JSON.parse(sv) : null;
     }
-    async awaitWorkflowResult(workflowID, timeoutSeconds, callerID, timerFuncID) {
-        const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
-        let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
+    async awaitWorkflowResult(workflowID, timeoutms) {
+        const pollingIntervalMs = 1000;
+        const et = timeoutms !== undefined ? new Date().getTime() + timeoutms : undefined;
         while (true) {
-            let resolveNotification;
-            const statusPromise = new Promise((resolve) => {
-                resolveNotification = resolve;
-            });
-            const irh = this.cancelWakeupMap.registerCallback(workflowID, (_res) => {
-                resolveNotification();
-            });
-            const crh = callerID
-                ? this.cancelWakeupMap.registerCallback(callerID, (_res) => {
-                    resolveNotification();
-                })
-                : undefined;
-            try {
-                if (callerID)
-                    await this.checkIfCanceled(callerID);
-                try {
-                    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 { res: rows[0].output };
-                        }
-                        else if (status === workflow_1.StatusString.ERROR) {
-                            return { err: rows[0].error };
-                        }
-                        else if (status === workflow_1.StatusString.CANCELLED) {
-                            return { cancelled: true };
-                        }
-                        else {
-                            // Status is not actionable
-                        }
-                    }
+            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 { res: rows[0].output };
                 }
-                catch (e) {
-                    const err = e;
-                    this.logger.error(`Exception from system database: ${err}`);
-                    throw err;
+                else if (status === workflow_1.StatusString.ERROR) {
+                    return { err: rows[0].error };
                 }
-                const ct = Date.now();
-                if (finishTime && ct > finishTime)
-                    return undefined; // Time's up
-                let timeoutPromise = Promise.resolve();
-                let timeoutCancel = () => { };
-                if (timerFuncID !== undefined && callerID !== undefined && timeoutms !== undefined) {
-                    const { promise, cancel, endTime } = await this.durableSleepmsInternal(callerID, timerFuncID, timeoutms, this.dbPollingIntervalMs);
-                    finishTime = endTime;
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
+            }
+            if (et !== undefined) {
+                const ct = new Date().getTime();
+                if (et > ct) {
+                    await (0, utils_1.sleepms)(Math.min(pollingIntervalMs, et - ct));
                 }
                 else {
-                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalMs;
-                    poll = Math.min(this.dbPollingIntervalMs, poll);
-                    const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                }
-                try {
-                    await Promise.race([statusPromise, timeoutPromise]);
-                }
-                finally {
-                    timeoutCancel();
+                    break;
                 }
             }
-            finally {
-                this.cancelWakeupMap.deregisterCallback(irh);
-                if (crh)
-                    this.cancelWakeupMap.deregisterCallback(crh);
+            else {
+                await (0, utils_1.sleepms)(pollingIntervalMs);
             }
         }
+        return undefined;
     }
     /* BACKGROUND PROCESSES */
     /**
@@ -866,29 +726,15 @@ class PostgresSystemDatabase {
         this.notificationsClient = await this.pool.connect();
         await this.notificationsClient.query('LISTEN dbos_notifications_channel;');
         await this.notificationsClient.query('LISTEN dbos_workflow_events_channel;');
-        await this.notificationsClient.query('LISTEN dbos_workflow_cancel_channel;');
         const handler = (msg) => {
-            if (!this.shouldUseDBNotifications)
-                return; // Testing parameter
             if (msg.channel === 'dbos_notifications_channel') {
-                if (msg.payload) {
-                    this.notificationsMap.callCallbacks(msg.payload);
-                }
-            }
-            else if (msg.channel === 'dbos_workflow_events_channel') {
-                if (msg.payload) {
-                    this.workflowEventsMap.callCallbacks(msg.payload);
+                if (msg.payload && msg.payload in this.notificationsMap) {
+                    this.notificationsMap[msg.payload]();
                 }
             }
-            else if (msg.channel === 'dbos_workflow_cancel_channel') {
-                if (msg.payload) {
-                    const notif = JSON.parse(msg.payload);
-                    if (notif.cancelled === 't') {
-                        this.setWFCancelMap(notif.wfid);
-                    }
-                    else {
-                        this.clearWFCancelMap(notif.wfid);
-                    }
+            else {
+                if (msg.payload && msg.payload in this.workflowEventsMap) {
+                    this.workflowEventsMap[msg.payload]();
                 }
             }
         };
@@ -941,29 +787,35 @@ class PostgresSystemDatabase {
                 : undefined,
         };
     }
-    async getWorkflows(input) {
+    async listWorkflows(input) {
+        const schemaName = dbos_executor_1.DBOSExecutor.systemDBSchemaName;
         input.sortDesc = input.sortDesc ?? false; // By default, sort in ascending order
-        let query = this.knexDB(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status`).orderBy('created_at', input.sortDesc ? 'desc' : 'asc');
+        let query = this.knexDB(`${schemaName}.workflow_status`)
+            .join(`${schemaName}.workflow_inputs`, `${schemaName}.workflow_status.workflow_uuid`, `${schemaName}.workflow_inputs.workflow_uuid`)
+            .orderBy(`${schemaName}.workflow_status.created_at`, input.sortDesc ? 'desc' : 'asc');
         if (input.workflowName) {
-            query = query.where('name', input.workflowName);
+            query = query.where(`${schemaName}.workflow_status.name`, input.workflowName);
+        }
+        if (input.workflow_id_prefix) {
+            query = query.whereLike(`${schemaName}.workflow_status.workflow_uuid`, `${input.workflow_id_prefix}%`);
         }
         if (input.workflowIDs) {
-            query = query.whereIn('workflow_uuid', input.workflowIDs);
+            query = query.whereIn(`${schemaName}.workflow_status.workflow_uuid`, input.workflowIDs);
         }
         if (input.authenticatedUser) {
-            query = query.where('authenticated_user', input.authenticatedUser);
+            query = query.where(`${schemaName}.workflow_status.authenticated_user`, input.authenticatedUser);
         }
         if (input.startTime) {
-            query = query.where('created_at', '>=', new Date(input.startTime).getTime());
+            query = query.where(`${schemaName}.workflow_status.created_at`, '>=', new Date(input.startTime).getTime());
         }
         if (input.endTime) {
-            query = query.where('created_at', '<=', new Date(input.endTime).getTime());
+            query = query.where(`${schemaName}.workflow_status.created_at`, '<=', new Date(input.endTime).getTime());
         }
         if (input.status) {
-            query = query.where('status', input.status);
+            query = query.where(`${schemaName}.workflow_status.status`, input.status);
         }
         if (input.applicationVersion) {
-            query = query.where('application_version', input.applicationVersion);
+            query = query.where(`${schemaName}.workflow_status.application_version`, input.applicationVersion);
         }
         if (input.limit) {
             query = query.limit(input.limit);
@@ -971,31 +823,30 @@ class PostgresSystemDatabase {
         if (input.offset) {
             query = query.offset(input.offset);
         }
-        const rows = await query.select('workflow_uuid');
-        const workflowUUIDs = rows.map((row) => row.workflow_uuid);
-        return {
-            workflowUUIDs: workflowUUIDs,
-        };
+        const rows = await query;
+        return rows.map(PostgresSystemDatabase.#mapWorkflowStatus);
     }
-    async getQueuedWorkflows(input) {
+    async listQueuedWorkflows(input) {
+        const schemaName = dbos_executor_1.DBOSExecutor.systemDBSchemaName;
         const sortDesc = input.sortDesc ?? false; // By default, sort in ascending order
-        let query = this.knexDB(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue`)
-            .join(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status`, `${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue.workflow_uuid`, '=', `${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status.workflow_uuid`)
-            .orderBy(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status.created_at`, sortDesc ? 'desc' : 'asc');
+        let query = this.knexDB(`${schemaName}.workflow_queue`)
+            .join(`${schemaName}.workflow_inputs`, `${schemaName}.workflow_queue.workflow_uuid`, `${schemaName}.workflow_inputs.workflow_uuid`)
+            .join(`${schemaName}.workflow_status`, `${schemaName}.workflow_queue.workflow_uuid`, `${schemaName}.workflow_status.workflow_uuid`)
+            .orderBy(`${schemaName}.workflow_status.created_at`, sortDesc ? 'desc' : 'asc');
         if (input.workflowName) {
-            query = query.whereRaw(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status.name = ?`, [input.workflowName]);
+            query = query.whereRaw(`${schemaName}.workflow_status.name = ?`, [input.workflowName]);
         }
         if (input.queueName) {
-            query = query.whereRaw(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status.queue_name = ?`, [input.queueName]);
+            query = query.whereRaw(`${schemaName}.workflow_status.queue_name = ?`, [input.queueName]);
         }
         if (input.startTime) {
-            query = query.where(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status.created_at`, '>=', new Date(input.startTime).getTime());
+            query = query.where(`${schemaName}.workflow_status.created_at`, '>=', new Date(input.startTime).getTime());
         }
         if (input.endTime) {
-            query = query.where(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status.created_at`, '<=', new Date(input.endTime).getTime());
+            query = query.where(`${schemaName}.workflow_status.created_at`, '<=', new Date(input.endTime).getTime());
         }
         if (input.status) {
-            query = query.whereRaw(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status.status = ?`, [input.status]);
+            query = query.whereRaw(`${schemaName}.workflow_status.status = ?`, [input.status]);
         }
         if (input.limit) {
             query = query.limit(input.limit);
@@ -1003,10 +854,30 @@ class PostgresSystemDatabase {
         if (input.offset) {
             query = query.offset(input.offset);
         }
-        const rows = await query.select(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status.workflow_uuid`);
-        const workflowUUIDs = rows.map((row) => row.workflow_uuid);
+        const rows = await query;
+        return rows.map(PostgresSystemDatabase.#mapWorkflowStatus);
+    }
+    static #mapWorkflowStatus(row) {
         return {
-            workflowUUIDs: workflowUUIDs,
+            workflowUUID: row.workflow_uuid,
+            status: row.status,
+            workflowName: row.name,
+            output: row.output ? row.output : null,
+            error: row.error ? row.error : null,
+            workflowClassName: row.class_name ?? '',
+            workflowConfigName: row.config_name ?? '',
+            queueName: row.queue_name,
+            authenticatedUser: row.authenticated_user,
+            assumedRole: row.assumed_role,
+            authenticatedRoles: JSON.parse(row.authenticated_roles),
+            request: JSON.parse(row.request),
+            executorId: row.executor_id,
+            createdAt: Number(row.created_at),
+            updatedAt: Number(row.updated_at),
+            applicationVersion: row.application_version,
+            applicationID: row.application_id,
+            recoveryAttempts: Number(row.recovery_attempts),
+            input: row.inputs,
         };
     }
     async getWorkflowQueue(input) {
@@ -1085,7 +956,7 @@ class PostgresSystemDatabase {
     }
     async dequeueWorkflow(workflowId, queue) {
         if (queue.rateLimit) {
-            const time = Date.now();
+            const time = new Date().getTime();
             await this.pool.query(`
         UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue
         SET completed_at_epoch_ms = $2
@@ -1100,7 +971,7 @@ class PostgresSystemDatabase {
         }
     }
     async findAndMarkStartableWorkflows(queue, executorID, appVersion) {
-        const startTimeMs = Date.now();
+        const startTimeMs = new Date().getTime();
         const limiterPeriodMS = queue.rateLimit ? queue.rateLimit.periodSec * 1000 : 0;
         const claimedIDs = [];
         await this.knexDB.transaction(async (trx) => {