@dbos-inc/dbos-sdk 1.28.14-preview.g65f6845035 → 1.29.84-preview.gd5bdeb6a8d

package/dist/src/dbos-executor.js

@@ -4,10 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DBOSExecutor = exports.OperationType = exports.dbosNull = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
 const error_1 = require("./error");
 const workflow_1 = require("./workflow");
 const transaction_1 = require("./transaction");
+const step_1 = require("./step");
 const collector_1 = require("./telemetry/collector");
 const traces_1 = require("./telemetry/traces");
 const logs_1 = require("./telemetry/logs");
@@ -84,7 +84,9 @@ class DBOSExecutor {
     typeormEntities = [];
     drizzleEntities = {};
     eventReceivers = [];
-    scheduler = null;
+    scheduler = undefined;
+    wfqEnded = undefined;
+    static globalInstance = undefined;
     /* WORKFLOW EXECUTOR LIFE CYCLE MANAGEMENT */
     constructor(config, systemDatabase) {
         this.config = config;
@@ -143,6 +145,7 @@ class DBOSExecutor {
         }, this.flushBufferIntervalMs);
         this.logger.debug("Started workflow status buffer worker");
         this.initialized = false;
+        DBOSExecutor.globalInstance = this;
     }
     configureDbClient() {
         const userDbClient = this.config.userDbclient;
@@ -387,6 +390,9 @@ class DBOSExecutor {
         }
         await this.procedurePool.end();
         await this.logger.destroy();
+        if (DBOSExecutor.globalInstance === this) {
+            DBOSExecutor.globalInstance = undefined;
+        }
     }
     /* WORKFLOW OPERATIONS */
     #registerWorkflow(ro) {
@@ -401,6 +407,7 @@ class DBOSExecutor {
         const workflowInfo = {
             workflow: wf,
             config: { ...ro.workflowConfig },
+            registration: ro,
         };
         this.workflowInfoMap.set(wfn, workflowInfo);
         this.logger.debug(`Registered workflow ${wfn}`);
@@ -414,6 +421,7 @@ class DBOSExecutor {
         const txnInfo = {
             transaction: txf,
             config: { ...ro.txnConfig },
+            registration: ro,
         };
         this.transactionInfoMap.set(tfn, txnInfo);
         this.logger.debug(`Registered transaction ${tfn}`);
@@ -424,11 +432,12 @@ class DBOSExecutor {
         if (this.stepInfoMap.has(cfn)) {
             throw new error_1.DBOSError(`Repeated Commmunicator name: ${cfn}`);
         }
-        const commInfo = {
+        const stepInfo = {
             step: comm,
             config: { ...ro.commConfig },
+            registration: ro,
         };
-        this.stepInfoMap.set(cfn, commInfo);
+        this.stepInfoMap.set(cfn, stepInfo);
         this.logger.debug(`Registered step ${cfn}`);
     }
     #registerProcedure(ro) {
@@ -440,6 +449,7 @@ class DBOSExecutor {
         const procInfo = {
             procedure: proc,
             config: { ...ro.procConfig },
+            registration: ro,
         };
         this.procedureInfoMap.set(cfn, procInfo);
         this.logger.debug(`Registered stored proc ${cfn}`);
@@ -532,6 +542,28 @@ class DBOSExecutor {
             throw new error_1.DBOSNotRegisteredError(wf.name);
         }
         const wConfig = wInfo.config;
+        // Compatibility with the old way of calling workflows, which would include a parentCtx
+        const pctx = (0, context_1.getCurrentContextStore)();
+        const passContext = wInfo.registration?.passContext ?? true;
+        if (!passContext && pctx) {
+            const span = this.tracer.startSpan(wf.name, {
+                operationUUID: workflowUUID,
+                operationType: exports.OperationType.WORKFLOW,
+                status: workflow_1.StatusString.PENDING,
+                authenticatedUser: pctx.authenticatedUser,
+                assumedRole: pctx.assumedRole,
+                authenticatedRoles: pctx.authenticatedRoles,
+            }
+            // TODO the span should be taken from pctx
+            //pctx.span
+            );
+            params.parentCtx = new context_1.DBOSContextImpl(wf.name, span, this.logger);
+            params.parentCtx.request = pctx.request || {};
+            params.parentCtx.authenticatedUser = pctx.authenticatedUser || "";
+            params.parentCtx.assumedRole = pctx.assumedRole || "";
+            params.parentCtx.authenticatedRoles = pctx.authenticatedRoles || [];
+            params.parentCtx.workflowUUID = workflowUUID;
+        }
         const wCtxt = new workflow_1.WorkflowContextImpl(this, params.parentCtx, workflowUUID, wConfig, wf.name, presetUUID, params.tempWfType, params.tempWfName);
         const internalStatus = {
             workflowUUID: workflowUUID,
@@ -570,7 +602,16 @@ class DBOSExecutor {
             let result;
             // Execute the workflow.
             try {
-                result = await wf.call(params.configuredInstance, wCtxt, ...args);
+                let cresult;
+                await (0, context_1.runWithWorkflowContext)(wCtxt, async () => {
+                    if (passContext) {
+                        cresult = await wf.call(params.configuredInstance, wCtxt, ...args);
+                    }
+                    else {
+                        cresult = await wf.call(params.configuredInstance, ...args);
+                    }
+                });
+                result = cresult;
                 internalStatus.output = result;
                 internalStatus.status = workflow_1.StatusString.SUCCESS;
                 if (internalStatus.queueName) {
@@ -675,17 +716,19 @@ class DBOSExecutor {
         if (utils_1.DBOSJSON.stringify(args) !== utils_1.DBOSJSON.stringify(recordedInputs)) {
             throw new error_1.DBOSDebuggerError(`Detect different input for the workflow UUID ${workflowUUID}!\n Received: ${utils_1.DBOSJSON.stringify(args)}\n Original: ${utils_1.DBOSJSON.stringify(recordedInputs)}`);
         }
-        const workflowPromise = wf.call(params.configuredInstance, wCtxt, ...args)
-            .then(async (result) => {
-            // Check if the result is the same.
-            const recordedResult = await this.systemDatabase.getWorkflowResult(workflowUUID);
-            if (result === undefined && !recordedResult) {
-                return result;
-            }
-            if (utils_1.DBOSJSON.stringify(result) !== utils_1.DBOSJSON.stringify(recordedResult)) {
-                this.logger.error(`Detect different output for the workflow UUID ${workflowUUID}!\n Received: ${utils_1.DBOSJSON.stringify(result)}\n Original: ${utils_1.DBOSJSON.stringify(recordedResult)}`);
-            }
-            return recordedResult; // Always return the recorded result.
+        const workflowPromise = (0, context_1.runWithWorkflowContext)(wCtxt, async () => {
+            return await wf.call(params.configuredInstance, wCtxt, ...args)
+                .then(async (result) => {
+                // Check if the result is the same.
+                const recordedResult = await this.systemDatabase.getWorkflowResult(workflowUUID);
+                if (result === undefined && !recordedResult) {
+                    return result;
+                }
+                if (utils_1.DBOSJSON.stringify(result) !== utils_1.DBOSJSON.stringify(recordedResult)) {
+                    this.logger.error(`Detect different output for the workflow UUID ${workflowUUID}!\n Received: ${utils_1.DBOSJSON.stringify(result)}\n Original: ${utils_1.DBOSJSON.stringify(recordedResult)}`);
+                }
+                return recordedResult; // Always return the recorded result.
+            });
         });
         return new workflow_1.InvokedHandle(this.systemDatabase, workflowPromise, workflowUUID, wf.name, callerUUID, callerFunctionID);
     }
@@ -702,6 +745,122 @@ class DBOSExecutor {
             tempWfClass: (0, decorators_1.getRegisteredMethodClassName)(txn),
         }, ...args)).getResult();
     }
+    async callTransactionFunction(txn, clsinst, wfCtx, ...args) {
+        const txnInfo = this.getTransactionInfo(txn);
+        if (txnInfo === undefined) {
+            throw new error_1.DBOSNotRegisteredError(txn.name);
+        }
+        const readOnly = txnInfo.config.readOnly ?? false;
+        let retryWaitMillis = 1;
+        const backoffFactor = 1.5;
+        const maxRetryWaitMs = 2000; // Maximum wait 2 seconds.
+        const funcId = wfCtx.functionIDGetIncrement();
+        const span = this.tracer.startSpan(txn.name, {
+            operationUUID: wfCtx.workflowUUID,
+            operationType: exports.OperationType.TRANSACTION,
+            authenticatedUser: wfCtx.authenticatedUser,
+            assumedRole: wfCtx.assumedRole,
+            authenticatedRoles: wfCtx.authenticatedRoles,
+            readOnly: readOnly,
+            isolationLevel: txnInfo.config.isolationLevel,
+        }, wfCtx.span);
+        while (true) {
+            let txn_snapshot = "invalid";
+            const workflowUUID = wfCtx.workflowUUID;
+            const wrappedTransaction = async (client) => {
+                const tCtxt = new transaction_1.TransactionContextImpl(this.userDatabase.getName(), client, wfCtx, span, this.logger, funcId, txn.name);
+                // If the UUID is preset, it is possible this execution previously happened. Check, and return its original result if it did.
+                // Note: It is possible to retrieve a generated ID from a workflow handle, run a concurrent execution, and cause trouble for yourself. We recommend against this.
+                if (wfCtx.presetUUID) {
+                    const check = await wfCtx.checkTxExecution(client, funcId);
+                    txn_snapshot = check.txn_snapshot;
+                    if (check.output !== exports.dbosNull) {
+                        tCtxt.span.setAttribute("cached", true);
+                        tCtxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
+                        this.tracer.endSpan(tCtxt.span);
+                        return check.output;
+                    }
+                }
+                else {
+                    // Collect snapshot information for read-only transactions and non-preset UUID transactions, if not already collected above
+                    txn_snapshot = await wfCtx.retrieveTxSnapshot(client);
+                }
+                // For non-read-only transactions, flush the result buffer.
+                if (!readOnly) {
+                    await wfCtx.flushResultBuffer(client);
+                }
+                // Execute the user's transaction.
+                let cresult;
+                if (txnInfo.registration.passContext) {
+                    await (0, context_1.runWithTransactionContext)(tCtxt, async () => {
+                        cresult = await txn.call(clsinst, tCtxt, ...args);
+                    });
+                }
+                else {
+                    await (0, context_1.runWithTransactionContext)(tCtxt, async () => {
+                        const tf = txn;
+                        cresult = await tf.call(clsinst, ...args);
+                    });
+                }
+                const result = cresult;
+                // Record the execution, commit, and return.
+                if (readOnly) {
+                    // Buffer the output of read-only transactions instead of synchronously writing it.
+                    const readOutput = {
+                        output: result,
+                        txn_snapshot: txn_snapshot,
+                        created_at: Date.now(),
+                    };
+                    wfCtx.resultBuffer.set(funcId, readOutput);
+                }
+                else {
+                    try {
+                        // Synchronously record the output of write transactions and obtain the transaction ID.
+                        const pg_txn_id = await wfCtx.recordOutputTx(client, funcId, txn_snapshot, result);
+                        tCtxt.span.setAttribute("pg_txn_id", pg_txn_id);
+                        wfCtx.resultBuffer.clear();
+                    }
+                    catch (error) {
+                        if (this.userDatabase.isFailedSqlTransactionError(error)) {
+                            this.logger.error(`Postgres aborted the ${txn.name} @Transaction of Workflow ${workflowUUID}, but the function did not raise an exception.  Please ensure that the @Transaction method raises an exception if the database transaction is aborted.`);
+                            throw new error_1.DBOSFailedSqlTransactionError(workflowUUID, txn.name);
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                }
+                return result;
+            };
+            try {
+                const result = await this.userDatabase.transaction(wrappedTransaction, txnInfo.config);
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                this.tracer.endSpan(span);
+                return result;
+            }
+            catch (err) {
+                if (this.userDatabase.isRetriableTransactionError(err)) {
+                    // serialization_failure in PostgreSQL
+                    span.addEvent("TXN SERIALIZATION FAILURE", { "retryWaitMillis": retryWaitMillis }, performance.now());
+                    // Retry serialization failures.
+                    await (0, utils_1.sleepms)(retryWaitMillis);
+                    retryWaitMillis *= backoffFactor;
+                    retryWaitMillis = retryWaitMillis < maxRetryWaitMs ? retryWaitMillis : maxRetryWaitMs;
+                    continue;
+                }
+                // Record and throw other errors.
+                const e = err;
+                await this.userDatabase.transaction(async (client) => {
+                    await wfCtx.flushResultBuffer(client);
+                    await wfCtx.recordErrorTx(client, funcId, txn_snapshot, e);
+                }, { isolationLevel: transaction_1.IsolationLevel.ReadCommitted });
+                wfCtx.resultBuffer.clear();
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: e.message });
+                this.tracer.endSpan(span);
+                throw err;
+            }
+        }
+    }
     async procedure(proc, params, ...args) {
         // Create a workflow and call procedure.
         const temp_workflow = async (ctxt, ...args) => {
@@ -748,13 +907,128 @@ class DBOSExecutor {
             tempWfClass: (0, decorators_1.getRegisteredMethodClassName)(stepFn),
         }, ...args)).getResult();
     }
+    /**
+     * Execute a step function.
+     * If it encounters any error, retry according to its configured retry policy until the maximum number of attempts is reached, then throw an DBOSError.
+     * The step may execute many times, but once it is complete, it will not re-execute.
+     */
+    async callStepFunction(stepFn, clsInst, wfCtx, ...args) {
+        const commInfo = this.getStepInfo(stepFn);
+        if (commInfo === undefined) {
+            throw new error_1.DBOSNotRegisteredError(stepFn.name);
+        }
+        const funcID = wfCtx.functionIDGetIncrement();
+        const maxRetryIntervalSec = 3600; // Maximum retry interval: 1 hour
+        const span = this.tracer.startSpan(stepFn.name, {
+            operationUUID: wfCtx.workflowUUID,
+            operationType: exports.OperationType.COMMUNICATOR,
+            authenticatedUser: wfCtx.authenticatedUser,
+            assumedRole: wfCtx.assumedRole,
+            authenticatedRoles: wfCtx.authenticatedRoles,
+            retriesAllowed: commInfo.config.retriesAllowed,
+            intervalSeconds: commInfo.config.intervalSeconds,
+            maxAttempts: commInfo.config.maxAttempts,
+            backoffRate: commInfo.config.backoffRate,
+        }, wfCtx.span);
+        const ctxt = new step_1.StepContextImpl(wfCtx, funcID, span, this.logger, commInfo.config, stepFn.name);
+        await this.userDatabase.transaction(async (client) => {
+            await wfCtx.flushResultBuffer(client);
+        }, { isolationLevel: transaction_1.IsolationLevel.ReadCommitted });
+        wfCtx.resultBuffer.clear();
+        // Check if this execution previously happened, returning its original result if it did.
+        const check = await this.systemDatabase.checkOperationOutput(wfCtx.workflowUUID, ctxt.functionID);
+        if (check !== exports.dbosNull) {
+            ctxt.span.setAttribute("cached", true);
+            ctxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
+            this.tracer.endSpan(ctxt.span);
+            return check;
+        }
+        // Execute the step function.  If it throws an exception, retry with exponential backoff.
+        // After reaching the maximum number of retries, throw an DBOSError.
+        let result = exports.dbosNull;
+        let err = exports.dbosNull;
+        if (ctxt.retriesAllowed) {
+            let numAttempts = 0;
+            let intervalSeconds = ctxt.intervalSeconds;
+            if (intervalSeconds > maxRetryIntervalSec) {
+                this.logger.warn(`Step config interval exceeds maximum allowed interval, capped to ${maxRetryIntervalSec} seconds!`);
+            }
+            while (result === exports.dbosNull && numAttempts++ < ctxt.maxAttempts) {
+                try {
+                    let cresult;
+                    if (commInfo.registration.passContext) {
+                        await (0, context_1.runWithStepContext)(ctxt, async () => {
+                            cresult = await stepFn.call(clsInst, ctxt, ...args);
+                        });
+                    }
+                    else {
+                        await (0, context_1.runWithStepContext)(ctxt, async () => {
+                            const sf = stepFn;
+                            cresult = await sf.call(clsInst, ...args);
+                        });
+                    }
+                    result = cresult;
+                }
+                catch (error) {
+                    const e = error;
+                    this.logger.warn(`Error in step being automatically retried. Attempt ${numAttempts} of ${ctxt.maxAttempts}. ${e.stack}`);
+                    span.addEvent(`Step attempt ${numAttempts + 1} failed`, { "retryIntervalSeconds": intervalSeconds, "error": error.message }, performance.now());
+                    if (numAttempts < ctxt.maxAttempts) {
+                        // Sleep for an interval, then increase the interval by backoffRate.
+                        // Cap at the maximum allowed retry interval.
+                        await (0, utils_1.sleepms)(intervalSeconds * 1000);
+                        intervalSeconds *= ctxt.backoffRate;
+                        intervalSeconds = intervalSeconds < maxRetryIntervalSec ? intervalSeconds : maxRetryIntervalSec;
+                    }
+                }
+            }
+        }
+        else {
+            try {
+                let cresult;
+                if (commInfo.registration.passContext) {
+                    await (0, context_1.runWithStepContext)(ctxt, async () => {
+                        cresult = await stepFn.call(clsInst, ctxt, ...args);
+                    });
+                }
+                else {
+                    await (0, context_1.runWithStepContext)(ctxt, async () => {
+                        const sf = stepFn;
+                        cresult = await sf.call(clsInst, ...args);
+                    });
+                }
+                result = cresult;
+            }
+            catch (error) {
+                err = error;
+            }
+        }
+        // `result` can only be dbosNull when the step timed out
+        if (result === exports.dbosNull) {
+            // Record the error, then throw it.
+            err = err === exports.dbosNull ? new error_1.DBOSError("Step reached maximum retries.", 1) : err;
+            await this.systemDatabase.recordOperationError(wfCtx.workflowUUID, ctxt.functionID, err);
+            ctxt.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: err.message });
+            this.tracer.endSpan(ctxt.span);
+            throw err;
+        }
+        else {
+            // Record the execution and return.
+            await this.systemDatabase.recordOperationOutput(wfCtx.workflowUUID, ctxt.functionID, result);
+            ctxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
+            this.tracer.endSpan(ctxt.span);
+            return result;
+        }
+    }
     async send(destinationUUID, message, topic, idempotencyKey) {
         // Create a workflow and call send.
         const temp_workflow = async (ctxt, destinationUUID, message, topic) => {
             return await ctxt.send(destinationUUID, message, topic);
         };
         const workflowUUID = idempotencyKey ? destinationUUID + idempotencyKey : undefined;
-        return (await this.workflow(temp_workflow, { workflowUUID: workflowUUID, tempWfType: TempWorkflowType.send, configuredInstance: null }, destinationUUID, message, topic)).getResult();
+        return (await this.workflow(temp_workflow, {
+            workflowUUID: workflowUUID, tempWfType: TempWorkflowType.send, configuredInstance: null,
+        }, destinationUUID, message, topic)).getResult();
     }
     /**
      * Wait for a workflow to emit an event, then return its value.
@@ -765,8 +1039,17 @@ class DBOSExecutor {
     /**
      * Retrieve a handle for a workflow UUID.
      */
-    retrieveWorkflow(workflowUUID) {
-        return new workflow_1.RetrievedHandle(this.systemDatabase, workflowUUID);
+    retrieveWorkflow(workflowID) {
+        return new workflow_1.RetrievedHandle(this.systemDatabase, workflowID);
+    }
+    getWorkflowStatus(workflowID) {
+        return this.systemDatabase.getWorkflowStatus(workflowID);
+    }
+    getWorkflows(input) {
+        return this.systemDatabase.getWorkflows(input);
+    }
+    getWorkflowQueue(input) {
+        return this.systemDatabase.getWorkflowQueue(input);
     }
     async queryUserDB(sql, params) {
         if (params !== undefined) {
@@ -833,6 +1116,7 @@ class DBOSExecutor {
         }
         await this.scheduler?.destroyScheduler();
         wfqueue_1.wfQueueRunner.stop();
+        await this.wfqEnded;
     }
     async executeWorkflowUUID(workflowUUID, startNewWorkflow = false) {
         const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowUUID);
@@ -848,7 +1132,7 @@ class DBOSExecutor {
         if (wfInfo) {
             return this.workflow(wfInfo.workflow, {
                 workflowUUID: workflowStartUUID, parentCtx: parentCtx, configuredInstance: configuredInst, recovery: true,
-                queueName: wfStatus.queueName, executeWorkflow: true
+                queueName: wfStatus.queueName, executeWorkflow: true,
             }, 
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
             ...inputs);
@@ -906,8 +1190,12 @@ class DBOSExecutor {
             this.logger.error(`Unrecognized temporary workflow! UUID ${workflowUUID}, name ${wfName}`);
             throw new error_1.DBOSNotRegisteredError(wfName);
         }
+        return this.workflow(temp_workflow, {
+            workflowUUID: workflowStartUUID, parentCtx: parentCtx ?? undefined, configuredInstance: clsinst,
+            recovery: true, tempWfType, tempWfClass, tempWfName,
+        }, 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return this.workflow(temp_workflow, { workflowUUID: workflowStartUUID, parentCtx: parentCtx ?? undefined, configuredInstance: clsinst, recovery: true, tempWfType, tempWfClass, tempWfName }, ...inputs);
+        ...inputs);
     }
     async getEventDispatchState(svc, wfn, key) {
         return await this.systemDatabase.getEventDispatchState(svc, wfn, key);