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

package/dist/src/dbos-executor.js

@@ -37,7 +37,7 @@ const logs_1 = require("./telemetry/logs");
 const exporters_1 = require("./telemetry/exporters");
 const pg_1 = require("pg");
 const system_database_1 = require("./system_database");
-const uuid_1 = require("uuid");
+const node_crypto_1 = require("node:crypto");
 const user_database_1 = require("./user_database");
 const decorators_1 = require("./decorators");
 const api_1 = require("@opentelemetry/api");
@@ -55,12 +55,13 @@ const scheduler_1 = require("./scheduler/scheduler");
 const crypto = __importStar(require("crypto"));
 exports.dbosNull = {};
 function isDeprecatedDBOSConfig(config) {
-    return (config.poolConfig !== undefined ||
+    const isDeprecated = config.poolConfig !== undefined ||
         config.telemetry !== undefined ||
         config.system_database !== undefined ||
         config.env !== undefined ||
         config.application !== undefined ||
-        config.http !== undefined);
+        config.http !== undefined;
+    return isDeprecated;
 }
 exports.isDeprecatedDBOSConfig = isDeprecatedDBOSConfig;
 var DebugMode;
@@ -113,6 +114,8 @@ class DBOSExecutor {
     stepInfoMap = new Map();
     procedureInfoMap = new Map();
     registeredOperations = [];
+    pendingWorkflowMap = new Map(); // Map from workflowUUID to workflow promise
+    workflowCancellationMap = new Map(); // Map from workflowUUID to its cancellation status.
     telemetryCollector;
     static defaultNotificationTimeoutSec = 60;
     debugMode;
@@ -395,7 +398,10 @@ class DBOSExecutor {
     }
     async destroy() {
         try {
-            await this.systemDatabase.awaitRunningWorkflows();
+            if (this.pendingWorkflowMap.size > 0) {
+                this.logger.info('Waiting for pending workflows to finish.');
+                await Promise.allSettled(this.pendingWorkflowMap.values());
+            }
             await this.systemDatabase.destroy();
             if (this.userDatabase) {
                 await this.userDatabase.destroy();
@@ -554,7 +560,6 @@ class DBOSExecutor {
             applicationVersion: utils_1.globalParams.appVersion,
             applicationID: wCtxt.applicationID,
             createdAt: Date.now(), // Remember the start time of this workflow
-            maxRetries: wCtxt.maxRecoveryAttempts,
         };
         if (wCtxt.isTempWorkflow) {
             internalStatus.workflowName = `${DBOSExecutor.tempWorkflowName}-${wCtxt.tempWfOperationType}-${wCtxt.tempWfOperationName}`;
@@ -564,14 +569,15 @@ class DBOSExecutor {
         // Synchronously set the workflow's status to PENDING and record workflow inputs.
         // We have to do it for all types of workflows because operation_outputs table has a foreign key constraint on workflow status table.
         if (this.isDebugging) {
+            // TODO: remove call to getWorkflowInputs after #871 is merged
             const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowID);
             const wfInputs = await this.systemDatabase.getWorkflowInputs(workflowID);
             if (!wfStatus || !wfInputs) {
                 throw new error_1.DBOSDebuggerError(`Failed to find inputs for workflow UUID ${workflowID}`);
             }
             // Make sure we use the same input.
-            if (utils_1.DBOSJSON.stringify(args) !== wfInputs) {
-                throw new error_1.DBOSDebuggerError(`Detected different inputs for workflow UUID ${workflowID}.\n Received: ${utils_1.DBOSJSON.stringify(args)}\n Original: ${wfInputs}`);
+            if (utils_1.DBOSJSON.stringify(args) !== utils_1.DBOSJSON.stringify(wfInputs)) {
+                throw new error_1.DBOSDebuggerError(`Detected different inputs for workflow UUID ${workflowID}.\n Received: ${utils_1.DBOSJSON.stringify(args)}\n Original: ${utils_1.DBOSJSON.stringify(wfInputs)}`);
             }
             status = wfStatus.status;
         }
@@ -583,14 +589,14 @@ class DBOSExecutor {
                     return new workflow_1.RetrievedHandle(this.systemDatabase, cr.res.child, callerID, callerFunctionID);
                 }
             }
-            const ires = await this.systemDatabase.initWorkflowStatus(internalStatus, utils_1.DBOSJSON.stringify(args));
+            const ires = await this.systemDatabase.initWorkflowStatus(internalStatus, args, wCtxt.maxRecoveryAttempts);
             if (callerFunctionID !== undefined && callerID !== undefined) {
                 await this.systemDatabase.recordOperationResult(callerID, callerFunctionID, {
                     childWfId: workflowID,
                     functionName: internalStatus.workflowName,
                 }, true);
             }
-            args = utils_1.DBOSJSON.parse(ires.serializedInputs);
+            args = ires.args;
             status = ires.status;
             await (0, debugpoint_1.debugTriggerPoint)(debugpoint_1.DEBUG_TRIGGER_WORKFLOW_ENQUEUE);
         }
@@ -631,7 +637,7 @@ class DBOSExecutor {
                 wCtxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
             }
             catch (err) {
-                if (err instanceof error_1.DBOSWorkflowConflictError) {
+                if (err instanceof error_1.DBOSWorkflowConflictUUIDError) {
                     // Retrieve the handle and wait for the result.
                     const retrievedHandle = this.retrieveWorkflow(workflowID);
                     result = await retrievedHandle.getResult();
@@ -677,7 +683,16 @@ class DBOSExecutor {
         if (this.isDebugging ||
             (status !== 'SUCCESS' && status !== 'ERROR' && (params.queueName === undefined || params.executeWorkflow))) {
             const workflowPromise = runWorkflow();
-            this.systemDatabase.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.pendingWorkflowMap.delete(workflowID);
+            });
+            this.pendingWorkflowMap.set(workflowID, awaitWorkflowPromise);
             // Return the normal handle that doesn't capture errors.
             return new workflow_1.InvokedHandle(this.systemDatabase, workflowPromise, workflowID, wf.name, callerID, callerFunctionID);
         }
@@ -754,7 +769,7 @@ class DBOSExecutor {
         catch (error) {
             if (isKeyConflict(error)) {
                 // Serialization and primary key conflict (Postgres).
-                throw new error_1.DBOSWorkflowConflictError(workflowUUID);
+                throw new error_1.DBOSWorkflowConflictUUIDError(workflowUUID);
             }
             else {
                 throw error;
@@ -775,7 +790,7 @@ class DBOSExecutor {
         catch (error) {
             if (isKeyConflict(error)) {
                 // Serialization and primary key conflict (Postgres).
-                throw new error_1.DBOSWorkflowConflictError(workflowUUID);
+                throw new error_1.DBOSWorkflowConflictUUIDError(workflowUUID);
             }
             else {
                 throw error;
@@ -811,7 +826,9 @@ class DBOSExecutor {
         if (txnInfo === undefined) {
             throw new error_1.DBOSNotRegisteredError(txn.name);
         }
-        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+        if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
+            throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
+        }
         let retryWaitMillis = 1;
         const backoffFactor = 1.5;
         const maxRetryWaitMs = 2000; // Maximum wait 2 seconds.
@@ -825,7 +842,9 @@ class DBOSExecutor {
             isolationLevel: txnInfo.config.isolationLevel,
         }, wfCtx.span);
         while (true) {
-            await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+            if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
+                throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
+            }
             let txn_snapshot = 'invalid';
             const workflowUUID = wfCtx.workflowUUID;
             const wrappedTransaction = async (client) => {
@@ -959,7 +978,9 @@ class DBOSExecutor {
         if (procInfo === undefined) {
             throw new error_1.DBOSNotRegisteredError(proc.name);
         }
-        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+        if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
+            throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
+        }
         const executeLocally = this.isDebugging || (procInfo.config.executeLocally ?? false);
         const funcId = wfCtx.functionIDGetIncrement();
         const span = this.tracer.startSpan(proc.name, {
@@ -992,7 +1013,9 @@ class DBOSExecutor {
         const backoffFactor = 1.5;
         const maxRetryWaitMs = 2000; // Maximum wait 2 seconds.
         while (true) {
-            await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+            if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
+                throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
+            }
             let txn_snapshot = 'invalid';
             const wrappedProcedure = async (client) => {
                 const ctxt = new procedure_1.StoredProcedureContextImpl(client, wfCtx, span, this.logger, funcId, proc.name);
@@ -1101,7 +1124,9 @@ class DBOSExecutor {
         if (this.isDebugging) {
             throw new error_1.DBOSDebuggerError("Can't invoke stored procedure in debug mode.");
         }
-        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+        if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
+            throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
+        }
         const $jsonCtx = {
             request: wfCtx.request,
             authenticatedUser: wfCtx.authenticatedUser,
@@ -1192,7 +1217,9 @@ class DBOSExecutor {
         if (commInfo === undefined) {
             throw new error_1.DBOSNotRegisteredError(stepFn.name);
         }
-        await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+        if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
+            throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
+        }
         const funcID = wfCtx.functionIDGetIncrement();
         const maxRetryIntervalSec = 3600; // Maximum retry interval: 1 hour
         const span = this.tracer.startSpan(stepFn.name, {
@@ -1235,7 +1262,9 @@ class DBOSExecutor {
             }
             while (result === exports.dbosNull && numAttempts++ < ctxt.maxAttempts) {
                 try {
-                    await this.systemDatabase.checkIfCanceled(wfCtx.workflowUUID);
+                    if (this.workflowCancellationMap.get(wfCtx.workflowUUID) === true) {
+                        throw new error_1.DBOSWorkflowCancelledError(wfCtx.workflowUUID);
+                    }
                     let cresult;
                     if (commInfo.registration.passContext) {
                         await (0, context_1.runWithStepContext)(ctxt, numAttempts, async () => {
@@ -1326,13 +1355,57 @@ class DBOSExecutor {
     async getEvent(workflowUUID, key, timeoutSeconds = DBOSExecutor.defaultNotificationTimeoutSec) {
         return utils_1.DBOSJSON.parse(await this.systemDatabase.getEvent(workflowUUID, key, timeoutSeconds));
     }
+    async getMaxFunctionID(workflowID) {
+        const rows = await this.userDatabase.query(`SELECT max(function_id) as max_function_id FROM ${DBOSExecutor.systemDBSchemaName}.transaction_outputs WHERE workflow_uuid=$1`, workflowID);
+        if (rows.length === 0) {
+            return 0;
+        }
+        else {
+            return rows[0].max_function_id;
+        }
+    }
+    async cloneWorkflowTransactions(workflowID, forkedWorkflowUUID, startStep) {
+        const query = `
+      INSERT INTO dbos.transaction_outputs
+        (workflow_uuid,
+          function_id, 
+          output, 
+          error, 
+          txn_id, 
+          txn_snapshot,  
+          function_name)
+      SELECT $1 AS workflow_uuid, 
+          function_id, 
+          output, 
+          error, 
+          txn_id, 
+          txn_snapshot, 
+          function_name
+      FROM dbos.transaction_outputs WHERE workflow_uuid= $2 AND function_id < $3`;
+        await this.userDatabase.query(query, forkedWorkflowUUID, workflowID, startStep);
+    }
+    async getMaxStepID(workflowID) {
+        const maxAppFunctionID = await this.getMaxFunctionID(workflowID);
+        const maxSystemFunctionID = await this.systemDatabase.getMaxFunctionID(workflowID);
+        return Math.max(maxAppFunctionID, maxSystemFunctionID);
+    }
+    /**
+     * Fork a workflow.
+     * The forked workflow will be assigned a new ID.
+     */
+    async forkWorkflow(workflowID, startStep = 0) {
+        const forkedWorkflowID = this.#generateUUID();
+        await this.cloneWorkflowTransactions(workflowID, forkedWorkflowID, startStep);
+        await this.systemDatabase.forkWorkflow(workflowID, forkedWorkflowID, startStep);
+        return forkedWorkflowID;
+    }
     /**
      * Retrieve a handle for a workflow UUID.
      */
     retrieveWorkflow(workflowID) {
         return new workflow_1.RetrievedHandle(this.systemDatabase, workflowID);
     }
-    async runAsStep(callback, functionName, workflowID, functionID, childWfId) {
+    async runAsStep(callback, functionName, workflowID, functionID) {
         if (workflowID !== undefined && functionID !== undefined) {
             const res = await this.systemDatabase.getOperationResult(workflowID, functionID);
             if (res.res !== undefined) {
@@ -1345,22 +1418,28 @@ class DBOSExecutor {
         try {
             const output = await callback();
             if (workflowID !== undefined && functionID !== undefined) {
-                await this.systemDatabase.recordOperationResult(workflowID, functionID, { serialOutput: utils_1.DBOSJSON.stringify(output), functionName, childWfId }, true);
+                await this.systemDatabase.recordOperationResult(workflowID, functionID, { serialOutput: utils_1.DBOSJSON.stringify(output), functionName }, true);
             }
             return output;
         }
         catch (e) {
             if (workflowID !== undefined && functionID !== undefined) {
-                await this.systemDatabase.recordOperationResult(workflowID, functionID, { serialError: utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(e)), functionName, childWfId }, false);
+                await this.systemDatabase.recordOperationResult(workflowID, functionID, { serialError: utils_1.DBOSJSON.stringify((0, serialize_error_1.serializeError)(e)), functionName }, false);
             }
             throw e;
         }
     }
-    getWorkflowStatus(workflowID, callerID, callerFN) {
-        return this.systemDatabase.getWorkflowStatus(workflowID, callerID, callerFN);
+    async getWorkflowStatus(workflowID, callerID, callerFN) {
+        const status = await this.systemDatabase.getWorkflowStatus(workflowID, callerID, callerFN);
+        return status ? DBOSExecutor.toWorkflowStatus(status, true) : null;
+    }
+    async listWorkflows(input) {
+        const wfs = await this.systemDatabase.listWorkflows(input);
+        return wfs.map((wf) => DBOSExecutor.toWorkflowStatus(wf, true));
     }
-    getWorkflows(input) {
-        return this.systemDatabase.getWorkflows(input);
+    async listQueuedWorkflows(input) {
+        const wfs = await this.systemDatabase.listQueuedWorkflows(input);
+        return wfs.map((wf) => DBOSExecutor.toWorkflowStatus(wf, true));
     }
     getWorkflowQueue(input) {
         return this.systemDatabase.getWorkflowQueue(input);
@@ -1395,7 +1474,7 @@ class DBOSExecutor {
     }
     /* INTERNAL HELPERS */
     #generateUUID() {
-        return (0, uuid_1.v4)();
+        return (0, node_crypto_1.randomUUID)();
     }
     /**
      * A recovery process that by default runs during executor init time.
@@ -1475,13 +1554,13 @@ class DBOSExecutor {
         }
     }
     async executeWorkflowUUID(workflowID, startNewWorkflow = false) {
+        // TODO: remove call to getWorkflowInputs after #871 is merged
         const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowID);
-        const sInputs = await this.systemDatabase.getWorkflowInputs(workflowID);
-        if (!sInputs || !wfStatus) {
+        const inputs = await this.systemDatabase.getWorkflowInputs(workflowID);
+        if (!inputs || !wfStatus) {
             this.logger.error(`Failed to find inputs for workflowUUID: ${workflowID}`);
             throw new error_1.DBOSError(`Failed to find inputs for workflow UUID: ${workflowID}`);
         }
-        const inputs = utils_1.DBOSJSON.parse(sInputs);
         const parentCtx = this.#getRecoveryContext(workflowID, wfStatus);
         const { wfInfo, configuredInst } = this.getWorkflowInfoByStatus(wfStatus);
         // If starting a new workflow, assign a new UUID. Otherwise, use the workflow's original UUID.
@@ -1493,7 +1572,9 @@ class DBOSExecutor {
                 configuredInstance: configuredInst,
                 queueName: wfStatus.queueName,
                 executeWorkflow: true,
-            }, ...inputs);
+            }, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            ...inputs);
         }
         // Should be temporary workflows. Parse the name of the workflow.
         const wfName = wfStatus.workflowName;
@@ -1515,7 +1596,9 @@ class DBOSExecutor {
                 configuredInstance: clsInst,
                 queueName: wfStatus.queueName,
                 executeWorkflow: true,
-            }, undefined, undefined, ...inputs);
+            }, undefined, undefined, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            ...inputs);
         }
         else if (nameArr[1] === exports.TempWorkflowType.step) {
             const { commInfo, clsInst } = this.getStepInfoByNames(wfStatus.workflowClassName, nameArr[2], wfStatus.workflowConfigName);
@@ -1529,7 +1612,9 @@ class DBOSExecutor {
                 configuredInstance: clsInst,
                 queueName: wfStatus.queueName, // Probably null
                 executeWorkflow: true,
-            }, undefined, undefined, ...inputs);
+            }, undefined, undefined, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            ...inputs);
         }
         else if (nameArr[1] === exports.TempWorkflowType.send) {
             temp_workflow = async (ctxt, ...args) => {
@@ -1541,7 +1626,9 @@ class DBOSExecutor {
                 tempWfType: exports.TempWorkflowType.send,
                 queueName: wfStatus.queueName,
                 executeWorkflow: true,
-            }, ...inputs);
+            }, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            ...inputs);
         }
         else {
             this.logger.error(`Unrecognized temporary workflow! UUID ${workflowID}, name ${wfName}`);
@@ -1567,6 +1654,7 @@ class DBOSExecutor {
     async cancelWorkflow(workflowID) {
         await this.systemDatabase.cancelWorkflow(workflowID);
         this.logger.info(`Cancelling workflow ${workflowID}`);
+        this.workflowCancellationMap.set(workflowID, true);
     }
     async getWorkflowSteps(workflowID) {
         const outputs = await this.systemDatabase.getAllOperationResults(workflowID);
@@ -1588,8 +1676,8 @@ class DBOSExecutor {
         return merged;
     }
     async resumeWorkflow(workflowID) {
+        this.workflowCancellationMap.delete(workflowID);
         await this.systemDatabase.resumeWorkflow(workflowID);
-        return await this.executeWorkflowUUID(workflowID, false);
     }
     logRegisteredHTTPUrls() {
         this.logger.info('HTTP endpoints supported:');
@@ -1629,6 +1717,36 @@ class DBOSExecutor {
         }
         return hasher.digest('hex');
     }
+    static internalQueue = undefined;
+    static createInternalQueue() {
+        if (DBOSExecutor.internalQueue !== undefined) {
+            return;
+        }
+        DBOSExecutor.internalQueue = new wfqueue_1.WorkflowQueue(utils_1.INTERNAL_QUEUE_NAME);
+    }
+    static toWorkflowStatus(internal, getRequest = true) {
+        return {
+            workflowID: internal.workflowUUID,
+            status: internal.status,
+            workflowName: internal.workflowName,
+            workflowClassName: internal.workflowClassName,
+            workflowConfigName: internal.workflowConfigName,
+            queueName: internal.queueName,
+            authenticatedUser: internal.authenticatedUser,
+            assumedRole: internal.assumedRole,
+            authenticatedRoles: internal.authenticatedRoles,
+            input: internal.input ? utils_1.DBOSJSON.parse(internal.input) : undefined,
+            output: internal.output ? utils_1.DBOSJSON.parse(internal.output ?? null) : undefined,
+            error: internal.error ? (0, serialize_error_1.deserializeError)(utils_1.DBOSJSON.parse(internal.error)) : undefined,
+            request: getRequest ? internal.request : undefined,
+            executorId: internal.executorId,
+            applicationVersion: internal.applicationVersion,
+            applicationID: internal.applicationID,
+            recoveryAttempts: internal.recoveryAttempts,
+            createdAt: internal.createdAt,
+            updatedAt: internal.updatedAt,
+        };
+    }
 }
 exports.DBOSExecutor = DBOSExecutor;
 //# sourceMappingURL=dbos-executor.js.map