@dbos-inc/dbos-sdk 4.20.3-preview → 4.20.7-preview

package/dist/src/system_database.js

@@ -385,10 +385,8 @@ class SystemDatabase {
     notificationsMap = new NotificationMap();
     workflowEventsMap = new NotificationMap();
     streamsMap = new NotificationMap();
-    cancelWakeupMap = new NotificationMap();
     customPool = false;
     runningWorkflowMap = new Map(); // Map from workflowID to workflow promise, queue name and partition key
-    workflowCancellationMap = new Map(); // Map from workflowID to its cancellation status.
     constructor(systemDatabaseUrl, logger, serializer, sysDbPoolSize = exports.DEFAULT_POOL_SIZE, systemDatabasePool, schemaName = 'dbos', useListenNotify = true) {
         this.systemDatabaseUrl = systemDatabaseUrl;
         this.logger = logger;
@@ -517,9 +515,7 @@ class SystemDatabase {
     async recordWorkflowOutput(workflowID, status) {
         const client = await this.pool.connect();
         try {
-            await this.updateWorkflowStatus(client, workflowID, workflow_1.StatusString.SUCCESS, {
-                update: { output: status.output, resetDeduplicationID: true, setCompletedAt: true },
-            });
+            await this.#recordWorkflowOutcome(client, workflowID, workflow_1.StatusString.SUCCESS, { output: status.output });
         }
         finally {
             client.release();
@@ -528,14 +524,37 @@ class SystemDatabase {
     async recordWorkflowError(workflowID, status) {
         const client = await this.pool.connect();
         try {
-            await this.updateWorkflowStatus(client, workflowID, workflow_1.StatusString.ERROR, {
-                update: { error: status.error, resetDeduplicationID: true, setCompletedAt: true },
-            });
+            await this.#recordWorkflowOutcome(client, workflowID, workflow_1.StatusString.ERROR, { error: status.error });
         }
         finally {
             client.release();
         }
     }
+    // Record a workflow's terminal outcome (SUCCESS or ERROR), but never overwrite
+    // the terminal CANCELLED status: a workflow can be cancelled during its final
+    // step, and if so it must not be able to subsequently complete. If the
+    // workflow is cancelled, abort the function so it does not complete. This
+    // mirrors the cancellation check done before each step.
+    async #recordWorkflowOutcome(client, workflowID, status, outcome) {
+        let cancelled = false;
+        try {
+            await client.query('BEGIN');
+            await this.updateWorkflowStatus(client, workflowID, status, {
+                update: { ...outcome, resetDeduplicationID: true, setCompletedAt: true },
+                where: { notStatus: workflow_1.StatusString.CANCELLED },
+                throwOnFailure: false,
+            });
+            cancelled = (await this.getWorkflowStatusValue(client, workflowID)) === workflow_1.StatusString.CANCELLED;
+            await client.query('COMMIT');
+        }
+        catch (e) {
+            await client.query('ROLLBACK');
+            throw e;
+        }
+        if (cancelled) {
+            throw new error_1.DBOSWorkflowCancelledError(workflowID);
+        }
+    }
     async getPendingWorkflows(executorID, appVersion) {
         const getWorkflows = await this.pool.query(`SELECT workflow_uuid, queue_name 
        FROM "${this.schemaName}".workflow_status 
@@ -697,23 +716,11 @@ class SystemDatabase {
            completed_at = (EXTRACT(EPOCH FROM now()) * 1000)::bigint
        WHERE workflow_uuid = ANY($2)
          AND status NOT IN ($3, $4)`, [workflow_1.StatusString.CANCELLED, workflowIDs, workflow_1.StatusString.SUCCESS, workflow_1.StatusString.ERROR]);
-        for (const workflowID of workflowIDs) {
-            this.#setWFCancelMap(workflowID);
-        }
     }
     async checkIfCanceled(workflowID) {
-        const client = await this.pool.connect();
-        try {
-            await this.#checkIfCanceled(client, workflowID);
-        }
-        finally {
-            client.release();
-        }
+        await this.#checkIfCanceled(this.pool, workflowID);
     }
     async resumeWorkflows(workflowIDs, queueName) {
-        for (const workflowID of workflowIDs) {
-            this.#clearWFCancelMap(workflowID);
-        }
         await this.pool.query(`UPDATE "${this.schemaName}".workflow_status
        SET status = $1, queue_name = $2, recovery_attempts = 0,
            workflow_deadline_epoch_ms = NULL, deduplication_id = NULL,
@@ -768,7 +775,6 @@ class SystemDatabase {
         await this.pool.query(`DELETE FROM "${this.schemaName}".workflow_status WHERE workflow_uuid = ANY($1)`, [allIds]);
         for (const wfid of allIds) {
             this.runningWorkflowMap.delete(wfid);
-            this.workflowCancellationMap.delete(wfid);
         }
     }
     async forkWorkflow(workflowID, startStep, options = {}) {
@@ -1131,7 +1137,6 @@ class SystemDatabase {
             .finally(() => {
             // Remove itself from pending workflow map.
             this.runningWorkflowMap.delete(workflowID);
-            this.workflowCancellationMap.delete(workflowID);
         });
         this.runningWorkflowMap.set(workflowID, {
             promise: awaitWorkflowPromise,
@@ -1164,149 +1169,91 @@ class SystemDatabase {
             //throw new Error('Message notification map is not empty - shutdown is not clean.');
         }
     }
-    async awaitWorkflowResult(workflowID, timeoutSeconds, callerID, timerFuncID) {
+    async awaitWorkflowResult(workflowID, timeoutSeconds, callerID, timerFuncID, pollingIntervalMs) {
         const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
         let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
+        const pollIntervalMs = pollingIntervalMs ?? this.dbPollingIntervalResultMs;
         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;
+            if (callerID)
+                await this.checkIfCanceled(callerID);
             try {
-                if (callerID)
-                    await this.checkIfCanceled(callerID);
-                try {
-                    const { rows } = await this.pool.query(`SELECT status, output, error, serialization FROM "${this.schemaName}".workflow_status 
-             WHERE workflow_uuid=$1`, [workflowID]);
-                    if (rows.length > 0) {
-                        const status = rows[0].status;
-                        if (status === workflow_1.StatusString.SUCCESS) {
-                            return { output: rows[0].output, serialization: rows[0].serialization };
-                        }
-                        else if (status === workflow_1.StatusString.ERROR) {
-                            return { error: rows[0].error, serialization: rows[0].serialization };
-                        }
-                        else if (status === workflow_1.StatusString.CANCELLED) {
-                            return { cancelled: true };
-                        }
-                        else if (status === workflow_1.StatusString.MAX_RECOVERY_ATTEMPTS_EXCEEDED) {
-                            return { maxRecoveryAttemptsExceeded: true };
-                        }
-                        else {
-                            // Status is not actionable
-                        }
+                const { rows } = await this.pool.query(`SELECT status, output, error, serialization FROM "${this.schemaName}".workflow_status
+           WHERE workflow_uuid=$1`, [workflowID]);
+                if (rows.length > 0) {
+                    const status = rows[0].status;
+                    if (status === workflow_1.StatusString.SUCCESS) {
+                        return { output: rows[0].output, serialization: rows[0].serialization };
+                    }
+                    else if (status === workflow_1.StatusString.ERROR) {
+                        return { error: rows[0].error, serialization: rows[0].serialization };
+                    }
+                    else if (status === workflow_1.StatusString.CANCELLED) {
+                        return { cancelled: true };
+                    }
+                    else if (status === workflow_1.StatusString.MAX_RECOVERY_ATTEMPTS_EXCEEDED) {
+                        return { maxRecoveryAttemptsExceeded: true };
+                    }
+                    else {
+                        // Status is not actionable
                     }
-                }
-                catch (e) {
-                    const err = e;
-                    this.logger.error(`Exception from system database: ${err}`, err);
-                    throw err;
-                }
-                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.#durableSleep(callerID, timerFuncID, timeoutms, this.dbPollingIntervalResultMs);
-                    finishTime = endTime;
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                }
-                else {
-                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalResultMs;
-                    poll = Math.min(this.dbPollingIntervalResultMs, poll);
-                    const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                }
-                try {
-                    await Promise.race([statusPromise, timeoutPromise]);
-                }
-                finally {
-                    timeoutCancel();
                 }
             }
-            finally {
-                this.cancelWakeupMap.deregisterCallback(irh);
-                if (crh)
-                    this.cancelWakeupMap.deregisterCallback(crh);
+            catch (e) {
+                const err = e;
+                this.logger.error(`Exception from system database: ${err}`, err);
+                throw err;
+            }
+            const ct = Date.now();
+            if (finishTime && ct > finishTime)
+                return undefined; // Time's up
+            if (timerFuncID !== undefined && callerID !== undefined && timeoutms !== undefined) {
+                finishTime = await this.#durableSleep(callerID, timerFuncID, timeoutms);
             }
+            let poll = finishTime ? finishTime - Date.now() : pollIntervalMs;
+            poll = Math.min(pollIntervalMs, poll);
+            await (0, utils_1.sleepms)(poll);
         }
     }
-    async awaitFirstWorkflowId(workflowIds, callerID) {
+    async awaitFirstWorkflowId(workflowIds, callerID, pollingIntervalMs) {
         const placeholders = workflowIds.map((_, i) => `$${i + 1}`).join(', ');
+        const pollIntervalMs = pollingIntervalMs ?? this.dbPollingIntervalResultMs;
         while (true) {
-            let resolveNotification;
-            const wakeupPromise = new Promise((resolve) => {
-                resolveNotification = resolve;
-            });
-            // Register cancel callbacks for all target workflows and the caller.
-            const cbHandles = workflowIds.map((wfid) => this.cancelWakeupMap.registerCallback(wfid, () => resolveNotification()));
-            const callerCbHandle = callerID
-                ? this.cancelWakeupMap.registerCallback(callerID, () => resolveNotification())
-                : undefined;
-            try {
-                if (callerID)
-                    await this.checkIfCanceled(callerID);
-                const { rows } = await this.pool.query(`SELECT workflow_uuid FROM "${this.schemaName}".workflow_status
-           WHERE workflow_uuid IN (${placeholders})
-             AND status NOT IN ('${workflow_1.StatusString.PENDING}', '${workflow_1.StatusString.ENQUEUED}', '${workflow_1.StatusString.DELAYED}')
-           LIMIT 1`, workflowIds);
-                if (rows.length > 0) {
-                    return rows[0].workflow_uuid;
-                }
-                const { promise: sleepPromise, cancel: sleepCancel } = (0, utils_1.cancellableSleep)(this.dbPollingIntervalResultMs);
-                try {
-                    await Promise.race([wakeupPromise, sleepPromise]);
-                }
-                finally {
-                    sleepCancel();
-                }
-            }
-            finally {
-                for (const h of cbHandles) {
-                    this.cancelWakeupMap.deregisterCallback(h);
-                }
-                if (callerCbHandle)
-                    this.cancelWakeupMap.deregisterCallback(callerCbHandle);
+            if (callerID)
+                await this.checkIfCanceled(callerID);
+            const { rows } = await this.pool.query(`SELECT workflow_uuid FROM "${this.schemaName}".workflow_status
+         WHERE workflow_uuid IN (${placeholders})
+           AND status NOT IN ('${workflow_1.StatusString.PENDING}', '${workflow_1.StatusString.ENQUEUED}', '${workflow_1.StatusString.DELAYED}')
+         LIMIT 1`, workflowIds);
+            if (rows.length > 0) {
+                return rows[0].workflow_uuid;
+            }
+            await (0, utils_1.sleepms)(pollIntervalMs);
+        }
+    }
+    async awaitWorkflowIds(workflowIds, callerID, pollingIntervalMs) {
+        const remainingWorkflowIds = new Set(workflowIds);
+        const pollIntervalMs = pollingIntervalMs ?? this.dbPollingIntervalResultMs;
+        while (remainingWorkflowIds.size > 0) {
+            const currentWorkflowIds = [...remainingWorkflowIds];
+            if (callerID)
+                await this.checkIfCanceled(callerID);
+            const { rows } = await this.pool.query(`SELECT workflow_uuid FROM "${this.schemaName}".workflow_status
+         WHERE workflow_uuid = ANY($1::text[])
+           AND status NOT IN ('${workflow_1.StatusString.PENDING}', '${workflow_1.StatusString.ENQUEUED}', '${workflow_1.StatusString.DELAYED}')`, [currentWorkflowIds]);
+            for (const row of rows) {
+                remainingWorkflowIds.delete(row.workflow_uuid);
+            }
+            if (remainingWorkflowIds.size === 0) {
+                return;
             }
+            await (0, utils_1.sleepms)(pollIntervalMs);
         }
     }
     // ==================== Sleep ====================
     async durableSleepms(workflowID, functionID, durationMS) {
-        let cancelled = false;
-        let resolveNotification;
-        const cancelPromise = new Promise((resolve) => {
-            resolveNotification = () => {
-                cancelled = true;
-                resolve();
-            };
-        });
-        const cbr = this.cancelWakeupMap.registerCallback(workflowID, resolveNotification);
-        try {
-            const { cancel: cancelInitial, endTime } = await this.#durableSleep(workflowID, functionID, durationMS);
-            cancelInitial();
-            while (!cancelled && Date.now() < endTime) {
-                const { promise, cancel } = (0, utils_1.cancellableSleep)(Math.min(endTime - Date.now(), utils_1.sleepConfig.maxTimeoutMS));
-                try {
-                    await Promise.race([cancelPromise, promise]);
-                }
-                finally {
-                    cancel();
-                }
-            }
-        }
-        finally {
-            this.cancelWakeupMap.deregisterCallback(cbr);
+        const endTime = await this.#durableSleep(workflowID, functionID, durationMS);
+        while (Date.now() < endTime) {
+            await (0, utils_1.sleepms)(Math.min(endTime - Date.now(), utils_1.sleepConfig.maxTimeoutMS));
         }
         await this.checkIfCanceled(workflowID);
     }
@@ -1357,7 +1304,7 @@ class SystemDatabase {
             throw err;
         }
     }
-    async recv(workflowID, functionID, timeoutFunctionID, topic, timeoutSeconds = dbos_executor_1.DBOSExecutor.defaultNotificationTimeoutSec) {
+    async recv(workflowID, functionID, timeoutFunctionID, topic, timeoutSeconds = dbos_executor_1.DBOSExecutor.defaultNotificationTimeoutSec, pollingIntervalMs) {
         topic = topic ?? this.nullTopic;
         const startTime = Date.now();
         // First, check for previous executions.
@@ -1370,6 +1317,7 @@ class SystemDatabase {
         }
         const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
         let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
+        const pollIntervalMs = pollingIntervalMs ?? this.dbPollingIntervalEventMs;
         while (true) {
             // register the key with the global notifications listener.
             let resolveNotification;
@@ -1378,9 +1326,6 @@ class SystemDatabase {
             });
             const payload = `${workflowID}::${topic}`;
             const cbr = this.notificationsMap.registerCallback(payload, resolveNotification);
-            const crh = this.cancelWakeupMap.registerCallback(workflowID, (_res) => {
-                resolveNotification();
-            });
             try {
                 await this.checkIfCanceled(workflowID);
                 // Check if the key is already in the DB, then wait for the notification if it isn't.
@@ -1390,31 +1335,21 @@ class SystemDatabase {
                 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.#durableSleep(workflowID, timeoutFunctionID, timeoutms, this.dbPollingIntervalEventMs);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                    finishTime = endTime;
-                }
-                else {
-                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalEventMs;
-                    poll = Math.min(this.dbPollingIntervalEventMs, poll);
-                    const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
+                    finishTime = await this.#durableSleep(workflowID, timeoutFunctionID, timeoutms);
                 }
+                let poll = finishTime ? finishTime - Date.now() : pollIntervalMs;
+                poll = Math.min(pollIntervalMs, poll);
+                const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
                 try {
-                    await Promise.race([messagePromise, timeoutPromise]);
+                    await Promise.race([messagePromise, promise]);
                 }
                 finally {
-                    timeoutCancel();
+                    cancel();
                 }
             }
             finally {
                 this.notificationsMap.deregisterCallback(cbr);
-                this.cancelWakeupMap.deregisterCallback(crh);
             }
         }
         await this.checkIfCanceled(workflowID);
@@ -1488,7 +1423,7 @@ class SystemDatabase {
             client.release();
         }
     }
-    async getEvent(workflowID, key, timeoutSeconds, callerWorkflow) {
+    async getEvent(workflowID, key, timeoutSeconds, callerWorkflow, pollingIntervalMs) {
         const startTime = Date.now();
         // Check if the operation has been done before for OAOO (only do this inside a workflow).
         if (callerWorkflow) {
@@ -1506,6 +1441,7 @@ class SystemDatabase {
         const payloadKey = `${workflowID}::${key}`;
         const timeoutms = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : undefined;
         let finishTime = timeoutms !== undefined ? Date.now() + timeoutms : undefined;
+        const pollIntervalMs = pollingIntervalMs ?? this.dbPollingIntervalEventMs;
         // 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) {
@@ -1514,11 +1450,6 @@ class SystemDatabase {
                 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);
@@ -1535,32 +1466,21 @@ class SystemDatabase {
                 if (finishTime && ct > finishTime)
                     break; // Time's up
                 // 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.#durableSleep(callerWorkflow.workflowID, callerWorkflow.timeoutFunctionID ?? -1, timeoutms, this.dbPollingIntervalEventMs);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
-                    finishTime = endTime;
-                }
-                else {
-                    let poll = finishTime ? finishTime - ct : this.dbPollingIntervalEventMs;
-                    poll = Math.min(this.dbPollingIntervalEventMs, poll);
-                    const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
-                    timeoutPromise = promise;
-                    timeoutCancel = cancel;
+                    finishTime = await this.#durableSleep(callerWorkflow.workflowID, callerWorkflow.timeoutFunctionID ?? -1, timeoutms);
                 }
+                let poll = finishTime ? finishTime - Date.now() : pollIntervalMs;
+                poll = Math.min(pollIntervalMs, poll);
+                const { promise, cancel } = (0, utils_1.cancellableSleep)(poll);
                 try {
-                    await Promise.race([valuePromise, timeoutPromise]);
+                    await Promise.race([valuePromise, promise]);
                 }
                 finally {
-                    timeoutCancel();
+                    cancel();
                 }
             }
             finally {
                 this.workflowEventsMap.deregisterCallback(cbr);
-                if (crh)
-                    this.cancelWakeupMap.deregisterCallback(crh);
             }
         }
         // Record the output if it is inside a workflow.
@@ -2758,6 +2678,10 @@ class SystemDatabase {
             const param = args.push(where.status);
             whereClause += ` AND status=$${param}`;
         }
+        if (where.notStatus) {
+            const param = args.push(where.notStatus);
+            whereClause += ` AND status!=$${param}`;
+        }
         const result = await client.query(`UPDATE "${this.schemaName}".workflow_status ${setClause} ${whereClause}`, args);
         const throwOnFailure = options.throwOnFailure ?? true;
         if (throwOnFailure && result.rowCount !== 1) {
@@ -2832,31 +2756,18 @@ class SystemDatabase {
         });
         return output;
     }
-    #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 #checkIfCanceled(client, workflowID) {
-        if (this.workflowCancellationMap.get(workflowID) === true) {
-            throw new error_1.DBOSWorkflowCancelledError(workflowID);
-        }
         const statusValue = await this.getWorkflowStatusValue(client, workflowID);
         if (statusValue === workflow_1.StatusString.CANCELLED) {
             throw new error_1.DBOSWorkflowCancelledError(workflowID);
         }
     }
-    async #durableSleep(workflowID, functionID, durationMS, maxSleepPerIteration) {
-        if (maxSleepPerIteration === undefined)
-            maxSleepPerIteration = durationMS;
-        const curTime = Date.now();
-        let endTimeMs = curTime + durationMS;
+    // Durably records (or, on recovery, reads back) the wakeup deadline for a sleep or
+    // timeout so it survives recovery. Returns the absolute end time in epoch ms; the
+    // caller is responsible for actually waiting until then. Throws if the workflow has
+    // been cancelled.
+    async #durableSleep(workflowID, functionID, durationMS) {
+        const endTimeMs = Date.now() + durationMS;
         const client = await this.pool.connect();
         try {
             const res = await this.#getOperationResultAndThrowIfCancelled(client, workflowID, functionID);
@@ -2864,18 +2775,13 @@ class SystemDatabase {
                 if (res.functionName !== exports.DBOS_FUNCNAME_SLEEP) {
                     throw new error_1.DBOSUnexpectedStepError(workflowID, functionID, exports.DBOS_FUNCNAME_SLEEP, res.functionName);
                 }
-                endTimeMs = JSON.parse(res.output);
-            }
-            else {
-                await this.recordOperationResultInternal(client, workflowID, functionID, exports.DBOS_FUNCNAME_SLEEP, false, Date.now(), Date.now(), {
-                    output: serialization_1.DBOSPortableJSON.stringify(endTimeMs),
-                    serialization: serialization_1.DBOSPortableJSON.name(),
-                });
+                return JSON.parse(res.output);
             }
-            return {
-                ...(0, utils_1.cancellableSleep)(Math.max(Math.min(maxSleepPerIteration, endTimeMs - curTime), 0)),
-                endTime: endTimeMs,
-            };
+            await this.recordOperationResultInternal(client, workflowID, functionID, exports.DBOS_FUNCNAME_SLEEP, false, Date.now(), Date.now(), {
+                output: serialization_1.DBOSPortableJSON.stringify(endTimeMs),
+                serialization: serialization_1.DBOSPortableJSON.name(),
+            });
+            return endTimeMs;
         }
         finally {
             client.release();
@@ -3013,15 +2919,21 @@ __decorate([
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, String, Number]),
+    __metadata("design:paramtypes", [String, Number, String, Number, Number]),
     __metadata("design:returntype", Promise)
 ], SystemDatabase.prototype, "awaitWorkflowResult", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, String]),
+    __metadata("design:paramtypes", [Array, String, Number]),
     __metadata("design:returntype", Promise)
 ], SystemDatabase.prototype, "awaitFirstWorkflowId", null);
+__decorate([
+    dbRetry(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, String, Number]),
+    __metadata("design:returntype", Promise)
+], SystemDatabase.prototype, "awaitWorkflowIds", null);
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
@@ -3043,7 +2955,7 @@ __decorate([
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number, Number, String, Number]),
+    __metadata("design:paramtypes", [String, Number, Number, String, Number, Number]),
     __metadata("design:returntype", Promise)
 ], SystemDatabase.prototype, "recv", null);
 __decorate([
@@ -3055,7 +2967,7 @@ __decorate([
 __decorate([
     dbRetry(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, Number, Object]),
+    __metadata("design:paramtypes", [String, String, Number, Object, Number]),
     __metadata("design:returntype", Promise)
 ], SystemDatabase.prototype, "getEvent", null);
 __decorate([