@dbos-inc/dbos-sdk 0.8.40-preview → 0.8.41-preview

package/packages/dbos-cloud/dist/src/dbos-executor.js

@@ -0,0 +1,631 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBOSExecutor = exports.OperationType = exports.DBOSExecutorIDHeader = exports.dbosNull = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const error_1 = require("./error");
+const workflow_1 = require("./workflow");
+const collector_1 = require("./telemetry/collector");
+const traces_1 = require("./telemetry/traces");
+const logs_1 = require("./telemetry/logs");
+const exporters_1 = require("./telemetry/exporters");
+const system_database_1 = require("./system_database");
+const uuid_1 = require("uuid");
+const user_database_1 = require("./user_database");
+const decorators_1 = require("./decorators");
+const api_1 = require("@opentelemetry/api");
+const knex_1 = __importDefault(require("knex"));
+const context_1 = require("./context");
+const debug_workflow_1 = require("./debugger/debug_workflow");
+const serialize_error_1 = require("serialize-error");
+exports.dbosNull = {};
+exports.DBOSExecutorIDHeader = "dbos-executor-id";
+exports.OperationType = {
+    HANDLER: "handler",
+    WORKFLOW: "workflow",
+    TRANSACTION: "transaction",
+    COMMUNICATOR: "communicator",
+};
+const TempWorkflowType = {
+    transaction: "transaction",
+    external: "external",
+    send: "send",
+};
+class DBOSExecutor {
+    config;
+    initialized;
+    // User Database
+    userDatabase = null;
+    // System Database
+    systemDatabase;
+    // Temporary workflows are created by calling transaction/send/recv directly from the executor class
+    static tempWorkflowName = "temp_workflow";
+    workflowInfoMap = new Map([
+        // We initialize the map with an entry for temporary workflows.
+        [
+            DBOSExecutor.tempWorkflowName,
+            {
+                // eslint-disable-next-line @typescript-eslint/require-await
+                workflow: async () => this.logger.error("UNREACHABLE: Indirect invoke of temp workflow"),
+                config: {},
+            },
+        ],
+    ]);
+    transactionInfoMap = new Map();
+    communicatorInfoMap = new Map();
+    registeredOperations = [];
+    pendingWorkflowMap = new Map(); // Map from workflowUUID to workflow promise
+    workflowResultBuffer = new Map(); // Map from workflowUUID to its remaining result buffer.
+    telemetryCollector;
+    flushBufferIntervalMs = 1000;
+    flushBufferID;
+    static defaultNotificationTimeoutSec = 60;
+    debugMode;
+    static systemDBSchemaName = "dbos";
+    logger;
+    tracer;
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    entities = [];
+    /* WORKFLOW EXECUTOR LIFE CYCLE MANAGEMENT */
+    constructor(config, systemDatabase) {
+        this.config = config;
+        this.debugMode = config.debugProxy ? true : false;
+        if (config.telemetry?.OTLPExporter) {
+            const OTLPExporter = new exporters_1.TelemetryExporter(config.telemetry.OTLPExporter);
+            this.telemetryCollector = new collector_1.TelemetryCollector(OTLPExporter);
+        }
+        else {
+            // We always an collector to drain the signals queue, even if we don't have an exporter.
+            this.telemetryCollector = new collector_1.TelemetryCollector();
+        }
+        this.logger = new logs_1.GlobalLogger(this.telemetryCollector, this.config.telemetry?.logs);
+        this.tracer = new traces_1.Tracer(this.telemetryCollector);
+        if (this.debugMode) {
+            this.logger.info("Running in debug mode!");
+            try {
+                const url = new URL(this.config.debugProxy);
+                this.config.poolConfig.host = url.hostname;
+                this.config.poolConfig.port = parseInt(url.port, 10);
+                this.logger.info(`Debugging mode proxy: ${this.config.poolConfig.host}:${this.config.poolConfig.port}`);
+            }
+            catch (err) {
+                this.logger.error(err);
+                throw err;
+            }
+        }
+        if (systemDatabase) {
+            this.logger.debug("Using provided system database"); // XXX print the name or something
+            this.systemDatabase = systemDatabase;
+        }
+        else {
+            this.logger.debug("Using Postgres system database");
+            this.systemDatabase = new system_database_1.PostgresSystemDatabase(this.config.poolConfig, this.config.system_database, this.logger);
+        }
+        this.flushBufferID = setInterval(() => {
+            if (!this.debugMode) {
+                void this.flushWorkflowBuffers();
+            }
+        }, this.flushBufferIntervalMs);
+        this.logger.debug("Started workflow status buffer worker");
+        this.initialized = false;
+    }
+    configureDbClient() {
+        const userDbClient = this.config.userDbclient;
+        const userDBConfig = this.config.poolConfig;
+        if (userDbClient === user_database_1.UserDatabaseName.PRISMA) {
+            // TODO: make Prisma work with debugger proxy.
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-var-requires
+            const { PrismaClient } = require("@prisma/client");
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call
+            this.userDatabase = new user_database_1.PrismaUserDatabase(new PrismaClient());
+            this.logger.debug("Loaded Prisma user database");
+        }
+        else if (userDbClient === user_database_1.UserDatabaseName.TYPEORM) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-var-requires
+            const DataSourceExports = require("typeorm");
+            try {
+                this.userDatabase = new user_database_1.TypeORMDatabase(
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                new DataSourceExports.DataSource({
+                    type: "postgres", // perhaps should move to config file
+                    host: userDBConfig.host,
+                    port: userDBConfig.port,
+                    username: userDBConfig.user,
+                    password: userDBConfig.password,
+                    database: userDBConfig.database,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+                    entities: this.entities,
+                }));
+            }
+            catch (s) {
+                s.message = `Error loading TypeORM user database: ${s.message}`;
+                this.logger.error(s);
+            }
+            this.logger.debug("Loaded TypeORM user database");
+        }
+        else if (userDbClient === user_database_1.UserDatabaseName.KNEX) {
+            const knexConfig = {
+                client: "postgres",
+                connection: {
+                    host: userDBConfig.host,
+                    port: userDBConfig.port,
+                    user: userDBConfig.user,
+                    password: userDBConfig.password,
+                    database: userDBConfig.database,
+                    ssl: userDBConfig.ssl,
+                },
+            };
+            this.userDatabase = new user_database_1.KnexUserDatabase((0, knex_1.default)(knexConfig));
+            this.logger.debug("Loaded Knex user database");
+        }
+        else {
+            this.userDatabase = new user_database_1.PGNodeUserDatabase(userDBConfig);
+            this.logger.debug("Loaded Postgres user database");
+        }
+    }
+    #registerClass(cls) {
+        const registeredClassOperations = (0, decorators_1.getRegisteredOperations)(cls);
+        this.registeredOperations.push(...registeredClassOperations);
+        for (const ro of registeredClassOperations) {
+            if (ro.workflowConfig) {
+                const wf = ro.registeredFunction;
+                this.#registerWorkflow(wf, ro.workflowConfig);
+                this.logger.debug(`Registered workflow ${ro.name}`);
+            }
+            else if (ro.txnConfig) {
+                const tx = ro.registeredFunction;
+                this.#registerTransaction(tx, ro.txnConfig);
+                this.logger.debug(`Registered transaction ${ro.name}`);
+            }
+            else if (ro.commConfig) {
+                const comm = ro.registeredFunction;
+                this.#registerCommunicator(comm, ro.commConfig);
+                this.logger.debug(`Registered communicator ${ro.name}`);
+            }
+        }
+    }
+    async init(...classes) {
+        if (this.initialized) {
+            this.logger.error("Workflow executor already initialized!");
+            return;
+        }
+        try {
+            for (const cls of classes) {
+                const reg = (0, decorators_1.getOrCreateClassRegistration)(cls);
+                if (reg.ormEntities.length > 0) {
+                    this.entities = this.entities.concat(reg.ormEntities);
+                    this.logger.debug(`Loaded ${reg.ormEntities.length} ORM entities`);
+                }
+            }
+            this.configureDbClient();
+            if (!this.userDatabase) {
+                this.logger.error("No user database configured!");
+                throw new error_1.DBOSInitializationError("No user database configured!");
+            }
+            for (const cls of classes) {
+                this.#registerClass(cls);
+            }
+            // Debug mode doesn't need to initialize the DBs. Everything should appear to be read-only.
+            await this.userDatabase.init(this.debugMode);
+            if (!this.debugMode) {
+                await this.systemDatabase.init();
+                await this.recoverPendingWorkflows();
+            }
+        }
+        catch (err) {
+            err.message = `failed to initialize workflow executor: ${err.message}`;
+            this.logger.error(err);
+            throw new error_1.DBOSInitializationError(`${err.message}`);
+        }
+        this.initialized = true;
+        // Only execute init code if under non-debug mode
+        if (!this.debugMode) {
+            for (const v of this.registeredOperations) {
+                const m = v;
+                if (m.init === true) {
+                    this.logger.debug("Executing init method: " + m.name);
+                    await m.origFunction(new context_1.InitContext(this));
+                }
+            }
+        }
+        this.logger.info("Workflow executor initialized");
+    }
+    async destroy() {
+        if (this.pendingWorkflowMap.size > 0) {
+            this.logger.info("Waiting for pending workflows to finish.");
+            await Promise.allSettled(this.pendingWorkflowMap.values());
+        }
+        clearInterval(this.flushBufferID);
+        await this.flushWorkflowBuffers();
+        await this.systemDatabase.destroy();
+        await this.userDatabase.destroy();
+        await this.telemetryCollector.destroy();
+    }
+    /* WORKFLOW OPERATIONS */
+    #registerWorkflow(wf, config = {}) {
+        if (wf.name === DBOSExecutor.tempWorkflowName || this.workflowInfoMap.has(wf.name)) {
+            throw new error_1.DBOSError(`Repeated workflow name: ${wf.name}`);
+        }
+        const workflowInfo = {
+            workflow: wf,
+            config: config,
+        };
+        this.workflowInfoMap.set(wf.name, workflowInfo);
+    }
+    #registerTransaction(txn, params = {}) {
+        if (this.transactionInfoMap.has(txn.name)) {
+            throw new error_1.DBOSError(`Repeated Transaction name: ${txn.name}`);
+        }
+        const txnInfo = {
+            transaction: txn,
+            config: params,
+        };
+        this.transactionInfoMap.set(txn.name, txnInfo);
+    }
+    #registerCommunicator(comm, params = {}) {
+        if (this.communicatorInfoMap.has(comm.name)) {
+            throw new error_1.DBOSError(`Repeated Commmunicator name: ${comm.name}`);
+        }
+        const commInfo = {
+            communicator: comm,
+            config: params,
+        };
+        this.communicatorInfoMap.set(comm.name, commInfo);
+    }
+    async workflow(wf, params, ...args) {
+        if (this.debugMode) {
+            return this.debugWorkflow(wf, params, undefined, undefined, ...args);
+        }
+        return this.internalWorkflow(wf, params, undefined, undefined, ...args);
+    }
+    // If callerUUID and functionID are set, it means the workflow is invoked from within a workflow.
+    async internalWorkflow(wf, params, callerUUID, callerFunctionID, ...args) {
+        const workflowUUID = params.workflowUUID ? params.workflowUUID : this.#generateUUID();
+        const presetUUID = params.workflowUUID ? true : false;
+        const wInfo = this.workflowInfoMap.get(wf.name);
+        if (wInfo === undefined) {
+            throw new error_1.DBOSNotRegisteredError(wf.name);
+        }
+        const wConfig = wInfo.config;
+        const wCtxt = new workflow_1.WorkflowContextImpl(this, params.parentCtx, workflowUUID, wConfig, wf.name, presetUUID);
+        // This is to accomodate the testing runtime, that does not go through HTTP handlers to start workflows
+        // Ideally we would expose the executorID to the environment instead of propagating it through headers.
+        if (wCtxt.executorID === 'local' && wCtxt.request.headers && wCtxt.request.headers[exports.DBOSExecutorIDHeader]) {
+            wCtxt.executorID = wCtxt.request.headers[exports.DBOSExecutorIDHeader];
+        }
+        const internalStatus = {
+            workflowUUID: workflowUUID,
+            status: workflow_1.StatusString.PENDING,
+            name: wf.name,
+            authenticatedUser: wCtxt.authenticatedUser,
+            output: undefined,
+            error: "",
+            assumedRole: wCtxt.assumedRole,
+            authenticatedRoles: wCtxt.authenticatedRoles,
+            request: wCtxt.request,
+            executorID: wCtxt.executorID,
+        };
+        // Synchronously set the workflow's status to PENDING and record workflow inputs.
+        if (!wCtxt.isTempWorkflow) {
+            args = await this.systemDatabase.initWorkflowStatus(internalStatus, args);
+        }
+        else {
+            // For temporary workflows, instead asynchronously record inputs.
+            this.systemDatabase.bufferWorkflowInputs(workflowUUID, args);
+        }
+        const runWorkflow = async () => {
+            let result;
+            // Execute the workflow.
+            try {
+                result = await wf(wCtxt, ...args);
+                if (wCtxt.isTempWorkflow) {
+                    internalStatus.name = `${DBOSExecutor.tempWorkflowName}-${wCtxt.tempWfOperationType}-${wCtxt.tempWfOperationName}`;
+                }
+                internalStatus.output = result;
+                internalStatus.status = workflow_1.StatusString.SUCCESS;
+                this.systemDatabase.bufferWorkflowOutput(workflowUUID, internalStatus);
+                wCtxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
+            }
+            catch (err) {
+                if (err instanceof error_1.DBOSWorkflowConflictUUIDError) {
+                    // Retrieve the handle and wait for the result.
+                    const retrievedHandle = this.retrieveWorkflow(workflowUUID);
+                    result = await retrievedHandle.getResult();
+                    wCtxt.span.setAttribute("cached", true);
+                    wCtxt.span.setStatus({ code: api_1.SpanStatusCode.OK });
+                }
+                else {
+                    // Record the error.
+                    const e = err;
+                    this.logger.error(e);
+                    if (wCtxt.isTempWorkflow) {
+                        internalStatus.name = `${DBOSExecutor.tempWorkflowName}-${wCtxt.tempWfOperationType}-${wCtxt.tempWfOperationName}`;
+                    }
+                    internalStatus.error = JSON.stringify((0, serialize_error_1.serializeError)(e));
+                    internalStatus.status = workflow_1.StatusString.ERROR;
+                    await this.systemDatabase.recordWorkflowError(workflowUUID, internalStatus);
+                    // TODO: Log errors, but not in the tests when they're expected.
+                    wCtxt.span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: e.message });
+                    throw err;
+                }
+            }
+            finally {
+                this.tracer.endSpan(wCtxt.span);
+            }
+            // Asynchronously flush the result buffer.
+            if (wCtxt.resultBuffer.size > 0) {
+                this.workflowResultBuffer.set(wCtxt.workflowUUID, wCtxt.resultBuffer);
+            }
+            return result;
+        };
+        const workflowPromise = runWorkflow();
+        // 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(workflowUUID);
+        });
+        this.pendingWorkflowMap.set(workflowUUID, awaitWorkflowPromise);
+        // Return the normal handle that doesn't capture errors.
+        return new workflow_1.InvokedHandle(this.systemDatabase, workflowPromise, workflowUUID, wf.name, callerUUID, callerFunctionID);
+    }
+    /**
+     * DEBUG MODE workflow execution, skipping all the recording
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async debugWorkflow(wf, params, callerUUID, callerFunctionID, ...args) {
+        // In debug mode, we must have a specific workflow UUID.
+        if (!params.workflowUUID) {
+            throw new error_1.DBOSDebuggerError("Workflow UUID not found!");
+        }
+        const workflowUUID = params.workflowUUID;
+        const wInfo = this.workflowInfoMap.get(wf.name);
+        if (wInfo === undefined) {
+            throw new error_1.DBOSDebuggerError("Workflow unregistered! " + wf.name);
+        }
+        const wConfig = wInfo.config;
+        const wCtxt = new debug_workflow_1.WorkflowContextDebug(this, params.parentCtx, workflowUUID, wConfig, wf.name);
+        // A workflow must have run before.
+        const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowUUID);
+        const recordedInputs = await this.systemDatabase.getWorkflowInputs(workflowUUID);
+        if (!wfStatus || !recordedInputs) {
+            throw new error_1.DBOSDebuggerError("Workflow status or inputs not found! UUID: " + workflowUUID);
+        }
+        // Make sure we use the same input.
+        if (JSON.stringify(args) !== JSON.stringify(recordedInputs)) {
+            throw new error_1.DBOSDebuggerError(`Detect different input for the workflow UUID ${workflowUUID}!\n Received: ${JSON.stringify(args)}\n Original: ${JSON.stringify(recordedInputs)}`);
+        }
+        const workflowPromise = wf(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 (JSON.stringify(result) !== JSON.stringify(recordedResult)) {
+                this.logger.error(`Detect different output for the workflow UUID ${workflowUUID}!\n Received: ${JSON.stringify(result)}\n Original: ${JSON.stringify(recordedResult)}`);
+            }
+            return recordedResult; // Always return the recorded result.
+        });
+        return new workflow_1.InvokedHandle(this.systemDatabase, workflowPromise, workflowUUID, wf.name, callerUUID, callerFunctionID);
+    }
+    async transaction(txn, params, ...args) {
+        // Create a workflow and call transaction.
+        const temp_workflow = async (ctxt, ...args) => {
+            const ctxtImpl = ctxt;
+            ctxtImpl.tempWfOperationType = TempWorkflowType.transaction;
+            ctxtImpl.tempWfOperationName = txn.name;
+            return await ctxtImpl.transaction(txn, ...args);
+        };
+        return (await this.workflow(temp_workflow, params, ...args)).getResult();
+    }
+    async external(commFn, params, ...args) {
+        // Create a workflow and call external.
+        const temp_workflow = async (ctxt, ...args) => {
+            const ctxtImpl = ctxt;
+            ctxtImpl.tempWfOperationType = TempWorkflowType.external;
+            ctxtImpl.tempWfOperationName = commFn.name;
+            return await ctxtImpl.external(commFn, ...args);
+        };
+        return (await this.workflow(temp_workflow, params, ...args)).getResult();
+    }
+    async send(destinationUUID, message, topic, idempotencyKey) {
+        // Create a workflow and call send.
+        const temp_workflow = async (ctxt, destinationUUID, message, topic) => {
+            const ctxtImpl = ctxt;
+            ctxtImpl.tempWfOperationType = TempWorkflowType.send;
+            return await ctxt.send(destinationUUID, message, topic);
+        };
+        const workflowUUID = idempotencyKey ? destinationUUID + idempotencyKey : undefined;
+        return (await this.workflow(temp_workflow, { workflowUUID: workflowUUID }, destinationUUID, message, topic)).getResult();
+    }
+    /**
+     * Wait for a workflow to emit an event, then return its value.
+     */
+    async getEvent(workflowUUID, key, timeoutSeconds = DBOSExecutor.defaultNotificationTimeoutSec) {
+        return this.systemDatabase.getEvent(workflowUUID, key, timeoutSeconds);
+    }
+    /**
+     * Retrieve a handle for a workflow UUID.
+     */
+    retrieveWorkflow(workflowUUID) {
+        return new workflow_1.RetrievedHandle(this.systemDatabase, workflowUUID);
+    }
+    /* INTERNAL HELPERS */
+    #generateUUID() {
+        return (0, uuid_1.v4)();
+    }
+    /**
+     * A recovery process that by default runs during executor init time.
+     * It runs to completion all pending workflows that were executing when the previous executor failed.
+     */
+    async recoverPendingWorkflows(executorIDs = ["local"]) {
+        const pendingWorkflows = [];
+        for (const execID of executorIDs) {
+            this.logger.debug(`Recovering workflows of executor: ${execID}`);
+            const wIDs = await this.systemDatabase.getPendingWorkflows(execID);
+            pendingWorkflows.push(...wIDs);
+        }
+        const handlerArray = [];
+        for (const workflowUUID of pendingWorkflows) {
+            try {
+                handlerArray.push(await this.executeWorkflowUUID(workflowUUID));
+            }
+            catch (e) {
+                this.logger.warn(`Recovery of workflow ${workflowUUID} failed: ${e.message}`);
+            }
+        }
+        return handlerArray;
+    }
+    async executeWorkflowUUID(workflowUUID) {
+        const wfStatus = await this.systemDatabase.getWorkflowStatus(workflowUUID);
+        const inputs = await this.systemDatabase.getWorkflowInputs(workflowUUID);
+        if (!inputs || !wfStatus) {
+            this.logger.error(`Failed to find inputs for workflowUUID: ${workflowUUID}`);
+            throw new error_1.DBOSError(`Failed to find inputs for workflow UUID: ${workflowUUID}`);
+        }
+        const parentCtx = this.#getRecoveryContext(workflowUUID, wfStatus);
+        const wfInfo = this.workflowInfoMap.get(wfStatus.workflowName);
+        if (wfInfo) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            return this.workflow(wfInfo.workflow, { workflowUUID: workflowUUID, parentCtx: parentCtx ?? undefined }, ...inputs);
+        }
+        // Should be temporary workflows. Parse the name of the workflow.
+        const wfName = wfStatus.workflowName;
+        const nameArr = wfName.split("-");
+        if (!nameArr[0].startsWith(DBOSExecutor.tempWorkflowName)) {
+            throw new error_1.DBOSError(`This should never happen! Cannot find workflow info for a non-temporary workflow! UUID ${workflowUUID}, name ${wfName}`);
+        }
+        let temp_workflow;
+        if (nameArr[1] === TempWorkflowType.transaction) {
+            const txnInfo = this.transactionInfoMap.get(nameArr[2]);
+            if (!txnInfo) {
+                throw new error_1.DBOSError(`Cannot find transaction info for UUID ${workflowUUID}, name ${wfName}`);
+            }
+            temp_workflow = async (ctxt, ...args) => {
+                const ctxtImpl = ctxt;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument
+                return await ctxtImpl.transaction(txnInfo.transaction, ...args);
+            };
+        }
+        else if (nameArr[1] === TempWorkflowType.external) {
+            const commInfo = this.communicatorInfoMap.get(nameArr[2]);
+            if (!commInfo) {
+                throw new error_1.DBOSError(`Cannot find transaction info for UUID ${workflowUUID}, name ${wfName}`);
+            }
+            temp_workflow = async (ctxt, ...args) => {
+                const ctxtImpl = ctxt;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument
+                return await ctxtImpl.external(commInfo.communicator, ...args);
+            };
+        }
+        else if (nameArr[1] === TempWorkflowType.send) {
+            temp_workflow = async (ctxt, ...args) => {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                return await ctxt.send(args[0], args[1], args[2]);
+            };
+        }
+        else {
+            throw new error_1.DBOSError(`Unrecognized temporary workflow! UUID ${workflowUUID}, name ${wfName}`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        return this.workflow(temp_workflow, { workflowUUID: workflowUUID, parentCtx: parentCtx ?? undefined }, ...inputs);
+    }
+    #getRecoveryContext(workflowUUID, status) {
+        const executorID = status.request.headers && status.request.headers[exports.DBOSExecutorIDHeader] ? status.request.headers[exports.DBOSExecutorIDHeader] : "local";
+        const span = this.tracer.startSpan(status.workflowName, {
+            operationUUID: workflowUUID,
+            operationType: exports.OperationType.WORKFLOW,
+            status: status.status,
+            authenticatedUser: status.authenticatedUser,
+            assumedRole: status.assumedRole,
+            authenticatedRoles: status.authenticatedRoles,
+            executorID: executorID,
+        });
+        const oc = new context_1.DBOSContextImpl(status.workflowName, span, this.logger);
+        oc.request = status.request;
+        oc.authenticatedUser = status.authenticatedUser;
+        oc.authenticatedRoles = status.authenticatedRoles;
+        oc.assumedRole = status.assumedRole;
+        oc.workflowUUID = workflowUUID;
+        return oc;
+    }
+    /* BACKGROUND PROCESSES */
+    /**
+     * Periodically flush the workflow output buffer to the system database.
+     */
+    async flushWorkflowBuffers() {
+        if (this.initialized) {
+            await this.systemDatabase.flushWorkflowInputsBuffer();
+            await this.flushWorkflowResultBuffer();
+            await this.systemDatabase.flushWorkflowStatusBuffer();
+        }
+    }
+    async flushWorkflowResultBuffer() {
+        const localBuffer = new Map(this.workflowResultBuffer);
+        this.workflowResultBuffer.clear();
+        const totalSize = localBuffer.size;
+        const flushBatchSize = 50;
+        try {
+            let finishedCnt = 0;
+            while (finishedCnt < totalSize) {
+                let sqlStmt = "INSERT INTO dbos.transaction_outputs (workflow_uuid, function_id, output, error, txn_id, txn_snapshot) VALUES ";
+                let paramCnt = 1;
+                const values = [];
+                const batchUUIDs = [];
+                for (const [workflowUUID, wfBuffer] of localBuffer) {
+                    for (const [funcID, recorded] of wfBuffer) {
+                        const output = recorded.output;
+                        const txnSnapshot = recorded.txn_snapshot;
+                        if (paramCnt > 1) {
+                            sqlStmt += ", ";
+                        }
+                        sqlStmt += `($${paramCnt++}, $${paramCnt++}, $${paramCnt++}, $${paramCnt++}, null, $${paramCnt++})`;
+                        values.push(workflowUUID, funcID, JSON.stringify(output), JSON.stringify(null), txnSnapshot);
+                    }
+                    batchUUIDs.push(workflowUUID);
+                    finishedCnt++;
+                    if (batchUUIDs.length >= flushBatchSize) {
+                        // Cap at the batch size.
+                        break;
+                    }
+                }
+                this.logger.debug(sqlStmt);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                await this.userDatabase.query(sqlStmt, ...values);
+                // Clean up after each batch succeeds
+                batchUUIDs.forEach((value) => { localBuffer.delete(value); });
+            }
+        }
+        catch (error) {
+            error.message = `Error flushing workflow result buffer: ${error.message}`;
+            this.logger.error(error);
+            // If there is a failure in flushing the buffer, return items to the global buffer for retrying later.
+            for (const [workflowUUID, wfBuffer] of localBuffer) {
+                if (!this.workflowResultBuffer.has(workflowUUID)) {
+                    this.workflowResultBuffer.set(workflowUUID, wfBuffer);
+                }
+            }
+        }
+    }
+    logRegisteredHTTPUrls() {
+        this.logger.info("HTTP endpoints supported:");
+        this.registeredOperations.forEach((registeredOperation) => {
+            const ro = registeredOperation;
+            if (ro.apiURL) {
+                this.logger.info("    " + ro.apiType.padEnd(4) + "  :  " + ro.apiURL);
+                const roles = ro.getRequiredRoles();
+                if (roles.length > 0) {
+                    this.logger.info("        Required Roles: " + JSON.stringify(roles));
+                }
+            }
+        });
+    }
+}
+exports.DBOSExecutor = DBOSExecutor;
+//# sourceMappingURL=dbos-executor.js.map