@dbos-inc/dbos-sdk 0.8.45-preview.g56ba028de5 → 0.8.46-preview

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

@@ -1,631 +0,0 @@
-"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