@dbos-inc/dbos-sdk 2.11.7-preview.gc208400219 → 2.11.15-preview.gd8ed483d92

package/dist/src/dbos.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InitContext = exports.DBOS = exports.runAsWorkflowStep = exports.getExecutor = void 0;
+exports.InitContext = exports.DBOS = exports.runInternalStep = exports.getExecutor = void 0;
 const context_1 = require("./context");
 const dbos_executor_1 = require("./dbos-executor");
 const logs_1 = require("./telemetry/logs");
@@ -14,6 +14,7 @@ const middleware_1 = require("./httpServer/middleware");
 const user_database_1 = require("./user_database");
 const node_crypto_1 = require("node:crypto");
 const _1 = require(".");
+const _2 = require(".");
 const handlerTypes_1 = require("./httpServer/handlerTypes");
 const lodash_1 = require("lodash");
 const conductor_1 = require("./conductor/conductor");
@@ -63,23 +64,24 @@ function getExecutor() {
     return dbos_executor_1.DBOSExecutor.globalInstance;
 }
 exports.getExecutor = getExecutor;
-function runAsWorkflowStep(callback, funcName, childWFID) {
+function runInternalStep(callback, funcName, childWFID) {
     if (DBOS.isWithinWorkflow()) {
         if (DBOS.isInStep()) {
             // OK to use directly
-            return dbos_executor_1.DBOSExecutor.globalInstance.runAsStep(callback, funcName, undefined, undefined, childWFID);
+            return callback();
         }
         else if (DBOS.isInWorkflow()) {
             const wfctx = (0, context_1.assertCurrentWorkflowContext)();
-            return dbos_executor_1.DBOSExecutor.globalInstance.runAsStep(callback, funcName, DBOS.workflowID, wfctx.functionIDGetIncrement(), childWFID);
+            return dbos_executor_1.DBOSExecutor.globalInstance.runInternalStep(callback, funcName, DBOS.workflowID, // assume DBOS.workflowID is defined because of assertCurrentWorkflowContext call above
+            wfctx.functionIDGetIncrement(), childWFID);
         }
         else {
             throw new error_1.DBOSInvalidWorkflowTransitionError(`Invalid call to \`${funcName}\` inside a \`transaction\` or \`procedure\``);
         }
     }
-    return dbos_executor_1.DBOSExecutor.globalInstance.runAsStep(callback, funcName, undefined, undefined, childWFID);
+    return callback();
 }
-exports.runAsWorkflowStep = runAsWorkflowStep;
+exports.runInternalStep = runInternalStep;
 class DBOS {
     ///////
     // Lifecycle
@@ -204,6 +206,9 @@ class DBOS {
             return; // return for cases where process.exit is mocked
         }
         await dbos_executor_1.DBOSExecutor.globalInstance.initEventReceivers();
+        for (const [_n, ds] of decorators_1.transactionalDataSources) {
+            await ds.initialize();
+        }
         if (options?.conductorKey) {
             if (!options.conductorURL) {
                 const dbosDomain = process.env.DBOS_DOMAIN || 'cloud.dbos.dev';
@@ -310,6 +315,9 @@ class DBOS {
             await dbos_executor_1.DBOSExecutor.globalInstance.destroy();
             dbos_executor_1.DBOSExecutor.globalInstance = undefined;
         }
+        for (const [_n, ds] of decorators_1.transactionalDataSources) {
+            await ds.destroy();
+        }
         // Reset the global app version and executor ID
         utils_1.globalParams.appVersion = process.env.DBOS__APPVERSION || '';
         utils_1.globalParams.wasComputed = false;
@@ -636,9 +644,6 @@ class DBOS {
     //////
     // Workflow and other operations
     //////
-    static #runAsWorkflowStep(callback, funcName) {
-        return runAsWorkflowStep(callback, funcName);
-    }
     /**
      * Get the workflow status given a workflow ID
      * @param workflowID - ID of the workflow
@@ -671,7 +676,7 @@ class DBOS {
         if (DBOS.isWithinWorkflow() && timeoutSeconds !== undefined) {
             timerFuncID = (0, context_1.assertCurrentWorkflowContext)().functionIDGetIncrement();
         }
-        return await runAsWorkflowStep(async () => {
+        return await runInternalStep(async () => {
             const rres = await dbos_executor_1.DBOSExecutor.globalInstance.systemDatabase.awaitWorkflowResult(workflowID, timeoutSeconds, DBOS.workflowID, timerFuncID);
             if (!rres)
                 return null;
@@ -704,7 +709,7 @@ class DBOS {
      * @deprecated Use `DBOS.listWorkflows` instead
      */
     static async getWorkflows(input) {
-        return await DBOS.#runAsWorkflowStep(async () => {
+        return await runInternalStep(async () => {
             const wfs = await DBOS.#executor.listWorkflows(input);
             return { workflowUUIDs: wfs.map((wf) => wf.workflowID) };
         }, 'DBOS.getWorkflows');
@@ -715,7 +720,7 @@ class DBOS {
      * @returns `WorkflowStatus` array containing details of the matching workflows
      */
     static async listWorkflows(input) {
-        return await DBOS.#runAsWorkflowStep(async () => {
+        return await runInternalStep(async () => {
             return await DBOS.#executor.listWorkflows(input);
         }, 'DBOS.listWorkflows');
     }
@@ -725,7 +730,7 @@ class DBOS {
      * @returns `WorkflowStatus` array containing details of the matching workflows
      */
     static async listQueuedWorkflows(input) {
-        return await DBOS.#runAsWorkflowStep(async () => {
+        return await runInternalStep(async () => {
             return await DBOS.#executor.listQueuedWorkflows(input);
         }, 'DBOS.listQueuedWorkflows');
     }
@@ -735,7 +740,7 @@ class DBOS {
      * @returns `StepInfo` array listing the executed steps of the workflow. If the workflow is not found, `undefined` is returned.
      */
     static async listWorkflowSteps(workflowID) {
-        return await DBOS.#runAsWorkflowStep(async () => {
+        return await runInternalStep(async () => {
             return await DBOS.#executor.listWorkflowSteps(workflowID);
         }, 'DBOS.listWorkflowSteps');
     }
@@ -746,7 +751,7 @@ class DBOS {
      * @param workflowID - ID of the workflow
      */
     static async cancelWorkflow(workflowID) {
-        return await DBOS.#runAsWorkflowStep(async () => {
+        return await runInternalStep(async () => {
             return await DBOS.#executor.cancelWorkflow(workflowID);
         }, 'DBOS.cancelWorkflow');
     }
@@ -755,7 +760,7 @@ class DBOS {
      * @param workflowID - ID of the workflow
      */
     static async resumeWorkflow(workflowID) {
-        await DBOS.#runAsWorkflowStep(async () => {
+        await runInternalStep(async () => {
             return await DBOS.#executor.resumeWorkflow(workflowID);
         }, 'DBOS.resumeWorkflow');
         return this.retrieveWorkflow(workflowID);
@@ -769,7 +774,7 @@ class DBOS {
      * @throws DBOSInvalidStepIDError if the `startStep` is greater than the maximum step ID of the workflow
      */
     static async forkWorkflow(workflowID, startStep, options) {
-        const forkedID = await DBOS.#runAsWorkflowStep(async () => {
+        const forkedID = await runInternalStep(async () => {
             return await DBOS.#executor.forkWorkflow(workflowID, startStep, options);
         }, 'DBOS.forkWorkflow');
         return this.retrieveWorkflow(forkedID);
@@ -929,114 +934,39 @@ class DBOS {
             }, callback);
         }
     }
-    static startWorkflow(target, params) {
-        if (typeof target === 'function') {
-            return DBOS.#proxyInvokeWF(target, null, params);
-        }
-        else {
-            return DBOS.#proxyInvokeWF(target, target, params);
+    /**
+     * Start a workflow in the background, returning a handle that can be used to check status,
+     *   await the result, or otherwise interact with the workflow.
+     * @param func - The function to start.  If a class or instance method, supply `this` within `params`.
+     * @param params - `StartWorkflowFunctionParams` which may specify the ID, queue, `this`, or other parameters
+     * @param args - Arguments passed to `func`
+     * @returns `WorkflowHandle` which can be used to interact with the started workflow
+     */
+    static async startWorkflowFunction(params, func, ...args) {
+        const regOp = (0, decorators_1.getRegistrationForFunction)(func);
+        if (!regOp) {
+            throw new error_1.DBOSNotRegisteredError(func.name, `${func.name} is not a registered DBOS workflow function`);
         }
+        return await DBOS.#invokeWorkflow(params?.instance, regOp, args, params ?? {});
     }
-    static #proxyInvokeWF(object, configuredInstance, inParams) {
-        const ops = (0, decorators_1.getRegisteredOperations)(object);
-        const proxy = {};
-        let wfId = (0, context_1.getNextWFID)(inParams?.workflowID);
-        const pctx = (0, context_1.getCurrentContextStore)();
-        // If this is called from within a workflow, this is a child workflow,
-        //  For OAOO, we will need a consistent ID formed from the parent WF and call number
-        if (DBOS.isWithinWorkflow()) {
-            if (!DBOS.isInWorkflow()) {
-                throw new error_1.DBOSInvalidWorkflowTransitionError('Invalid call to `DBOS.startWorkflow` from within a `step` or `transaction`');
-            }
-            const wfctx = (0, context_1.assertCurrentWorkflowContext)();
-            const funcId = wfctx.functionIDGetIncrement();
-            wfId = wfId || wfctx.workflowUUID + '-' + funcId;
-            const wfParams = {
-                workflowUUID: wfId,
-                parentCtx: wfctx,
-                configuredInstance,
-                queueName: inParams?.queueName ?? pctx?.queueAssignedForWorkflows,
-                timeoutMS: inParams?.timeoutMS ?? pctx?.workflowTimeoutMS,
-                deadlineEpochMS: wfctx.deadlineEpochMS,
-                enqueueOptions: inParams?.enqueueOptions,
-            };
-            // Detach child deadline if a null timeout is configured
-            // We must check the inParams but also pctx (if the workflow was called withWorkflowTimeout)
-            if (inParams?.timeoutMS === null || pctx?.workflowTimeoutMS === null) {
-                wfParams.deadlineEpochMS = undefined;
-            }
-            for (const op of ops) {
-                if (op.workflowConfig) {
-                    proxy[op.name] = (...args) => dbos_executor_1.DBOSExecutor.globalInstance.internalWorkflow(op.registeredFunction, wfParams, wfctx.workflowUUID, funcId, ...args);
-                }
-                else if (op.txnConfig) {
-                    const txn = op.registeredFunction;
-                    proxy[op.name] = (...args) => dbos_executor_1.DBOSExecutor.globalInstance.startTransactionTempWF(txn, wfParams, wfctx.workflowUUID, funcId, ...args);
-                }
-                else if (op.stepConfig) {
-                    const step = op.registeredFunction;
-                    proxy[op.name] = (...args) => {
-                        return dbos_executor_1.DBOSExecutor.globalInstance.startStepTempWF(step, wfParams, wfctx.workflowUUID, funcId, ...args);
-                    };
-                }
-                else {
-                    proxy[op.name] = (..._args) => {
-                        throw new error_1.DBOSNotRegisteredError(op.name, `${op.name} is not a registered DBOS workflow, step, or transaction function`);
-                    };
+    static startWorkflow(target, params) {
+        const instance = typeof target === 'function' ? null : target;
+        if (instance && !(instance instanceof _2.ConfiguredInstance)) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError('Attempt to call `startWorkflow` on an object that is not a `ConfiguredInstance`');
+        }
+        const regOps = (0, decorators_1.getRegisteredOperations)(target);
+        const handler = {
+            get(target, p, receiver) {
+                const func = Reflect.get(target, p, receiver);
+                const regOp = (0, decorators_1.getRegistrationForFunction)(func) ?? regOps.find((op) => op.name === p);
+                if (regOp) {
+                    return (...args) => DBOS.#invokeWorkflow(instance, regOp, args, params);
                 }
-            }
-            augmentProxy(configuredInstance ?? object, proxy);
-            return proxy;
-        }
-        // Else, we setup a parent context that includes all the potential metadata the application could have set in DBOSLocalCtx
-        let parentCtx = undefined;
-        if (pctx) {
-            // If pctx has no span, e.g., has not been setup through `withTracedContext`, set up a parent span for the workflow here.
-            let span = pctx.span;
-            if (!span) {
-                span = DBOS.#executor.tracer.startSpan(pctx.operationCaller || 'startWorkflow', {
-                    operationUUID: wfId,
-                    operationType: pctx.operationType,
-                    authenticatedUser: pctx.authenticatedUser,
-                    assumedRole: pctx.assumedRole,
-                    authenticatedRoles: pctx.authenticatedRoles,
-                });
-            }
-            parentCtx = new context_1.DBOSContextImpl(pctx.operationCaller || 'startWorkflow', span, DBOS.logger);
-            parentCtx.request = pctx.request || {};
-            parentCtx.authenticatedUser = pctx.authenticatedUser || '';
-            parentCtx.assumedRole = pctx.assumedRole || '';
-            parentCtx.authenticatedRoles = pctx.authenticatedRoles || [];
-            parentCtx.workflowUUID = wfId || '';
-        }
-        const wfParams = {
-            workflowUUID: wfId,
-            queueName: inParams?.queueName ?? pctx?.queueAssignedForWorkflows,
-            enqueueOptions: inParams?.enqueueOptions,
-            configuredInstance,
-            parentCtx,
-            timeoutMS: inParams?.timeoutMS ?? pctx?.workflowTimeoutMS,
+                const name = typeof p === 'string' ? p : String(p);
+                throw new error_1.DBOSNotRegisteredError(name, `${name} is not a registered DBOS workflow function`);
+            },
         };
-        for (const op of ops) {
-            if (op.workflowConfig) {
-                proxy[op.name] = (...args) => DBOS.#executor.workflow(op.registeredFunction, wfParams, ...args);
-            }
-            else if (op.txnConfig) {
-                const txn = op.registeredFunction;
-                proxy[op.name] = (...args) => dbos_executor_1.DBOSExecutor.globalInstance.startTransactionTempWF(txn, wfParams, undefined, undefined, ...args);
-            }
-            else if (op.stepConfig) {
-                const step = op.registeredFunction;
-                proxy[op.name] = (...args) => dbos_executor_1.DBOSExecutor.globalInstance.startStepTempWF(step, wfParams, undefined, undefined, ...args);
-            }
-            else {
-                proxy[op.name] = (..._args) => {
-                    throw new error_1.DBOSNotRegisteredError(op.name, `${op.name} is not a registered DBOS workflow, step, or transaction function`);
-                };
-            }
-        }
-        augmentProxy(configuredInstance ?? object, proxy);
-        return proxy;
+        return new Proxy(target, handler);
     }
     static invoke(object) {
         if (!DBOS.isWithinWorkflow()) {
@@ -1244,85 +1174,113 @@ class DBOS {
     static workflow(config = {}) {
         function decorator(target, propertyKey, inDescriptor) {
             const { descriptor, registration } = (0, decorators_1.registerAndWrapDBOSFunction)(target, propertyKey, inDescriptor);
-            registration.setWorkflowConfig(config);
-            const invokeWrapper = async function (...rawArgs) {
-                const pctx = (0, context_1.getCurrentContextStore)();
-                let inst = undefined;
-                if (this === undefined || typeof this === 'function') {
-                    // This is static
-                }
-                else {
-                    inst = this;
-                    if (!('name' in inst)) {
-                        throw new error_1.DBOSInvalidWorkflowTransitionError('Attempt to call a `workflow` function on an object that is not a `ConfiguredInstance`');
-                    }
-                }
-                let wfId = (0, context_1.getNextWFID)(undefined);
-                // If this is called from within a workflow, this is a child workflow,
-                //  For OAOO, we will need a consistent ID formed from the parent WF and call number
-                if (DBOS.isWithinWorkflow()) {
-                    if (!DBOS.isInWorkflow()) {
-                        throw new error_1.DBOSInvalidWorkflowTransitionError('Invalid call to a `workflow` function from within a `step` or `transaction`');
-                    }
-                    const wfctx = (0, context_1.assertCurrentWorkflowContext)();
-                    const funcId = wfctx.functionIDGetIncrement();
-                    wfId = wfId || wfctx.workflowUUID + '-' + funcId;
-                    const params = {
-                        workflowUUID: wfId,
-                        parentCtx: wfctx,
-                        configuredInstance: inst,
-                        queueName: pctx?.queueAssignedForWorkflows,
-                        timeoutMS: pctx?.workflowTimeoutMS,
-                        deadlineEpochMS: wfctx.deadlineEpochMS,
-                    };
-                    // Detach child deadline if a null timeout is configured
-                    if (pctx?.workflowTimeoutMS === null) {
-                        params.deadlineEpochMS = undefined;
-                    }
-                    const cwfh = await dbos_executor_1.DBOSExecutor.globalInstance.internalWorkflow(registration.registeredFunction, params, wfctx.workflowUUID, funcId, ...rawArgs);
-                    return await cwfh.getResult();
-                }
-                // Else, we setup a parent context that includes all the potential metadata the application could have set in DBOSLocalCtx
-                let parentCtx = undefined;
-                if (pctx) {
-                    // If pctx has no span, e.g., has not been setup through `withTracedContext`, set up a parent span for the workflow here.
-                    let span = pctx.span;
-                    if (!span) {
-                        span = DBOS.#executor.tracer.startSpan(pctx.operationCaller || 'workflowCaller', {
-                            operationUUID: wfId,
-                            operationType: pctx.operationType,
-                            authenticatedUser: pctx.authenticatedUser,
-                            assumedRole: pctx.assumedRole,
-                            authenticatedRoles: pctx.authenticatedRoles,
-                        });
-                    }
-                    parentCtx = new context_1.DBOSContextImpl(pctx.operationCaller || 'workflowCaller', span, DBOS.logger);
-                    parentCtx.request = pctx.request || {};
-                    parentCtx.authenticatedUser = pctx.authenticatedUser || '';
-                    parentCtx.assumedRole = pctx.assumedRole || '';
-                    parentCtx.authenticatedRoles = pctx.authenticatedRoles || [];
-                    parentCtx.workflowUUID = wfId || '';
-                }
-                const wfParams = {
-                    workflowUUID: wfId,
-                    queueName: pctx?.queueAssignedForWorkflows,
-                    configuredInstance: inst,
-                    parentCtx,
-                    timeoutMS: pctx?.workflowTimeoutMS,
-                };
-                const handle = await DBOS.#executor.workflow(registration.registeredFunction, wfParams, ...rawArgs);
-                return await handle.getResult();
-            };
-            descriptor.value = invokeWrapper;
-            registration.wrappedFunction = invokeWrapper;
-            Object.defineProperty(invokeWrapper, 'name', {
-                value: registration.name,
-            });
-            (0, decorators_1.registerFunctionWrapper)(invokeWrapper, registration);
+            const invoker = DBOS.#getWorkflowInvoker(registration, config);
+            descriptor.value = invoker;
+            registration.wrappedFunction = invoker;
             return descriptor;
         }
         return decorator;
     }
+    /**
+     * Create a DBOS workflow function from a provided function.
+     *   Similar to the DBOS.workflow, but without requiring a decorator
+     *   Durable execution will be applied to calls to the function returned by registerWorkflow
+     *   This also registers the function so that it is available during recovery
+     * @param func - The function to register as a workflow
+     * @param name - The name of the registered workflow
+     * @param options - Configuration information for the registered workflow
+     */
+    static registerWorkflow(func, name, options = {}) {
+        const { registration } = (0, decorators_1.registerAndWrapDBOSFunctionByName)(options.classOrInst, options.className, name, func);
+        return DBOS.#getWorkflowInvoker(registration, options.config);
+    }
+    static async #invokeWorkflow($this, regOP, args, params = {}) {
+        const wfId = (0, context_1.getNextWFID)(params.workflowID);
+        const pctx = (0, context_1.getCurrentContextStore)();
+        const queueName = params.queueName ?? pctx?.queueAssignedForWorkflows;
+        const timeoutMS = params.timeoutMS ?? pctx?.workflowTimeoutMS;
+        const instance = $this === undefined || typeof $this === 'function' ? undefined : $this;
+        if (instance && !(instance instanceof _2.ConfiguredInstance)) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError('Attempt to call a `workflow` function on an object that is not a `ConfiguredInstance`');
+        }
+        // If this is called from within a workflow, this is a child workflow,
+        //  For OAOO, we will need a consistent ID formed from the parent WF and call number
+        if (DBOS.isWithinWorkflow()) {
+            if (!DBOS.isInWorkflow()) {
+                throw new error_1.DBOSInvalidWorkflowTransitionError('Invalid call to a `workflow` function from within a `step` or `transaction`');
+            }
+            const wfctx = (0, context_1.assertCurrentWorkflowContext)();
+            const funcId = wfctx.functionIDGetIncrement();
+            const wfParams = {
+                workflowUUID: wfId || wfctx.workflowUUID + '-' + funcId,
+                parentCtx: wfctx,
+                configuredInstance: instance,
+                queueName,
+                timeoutMS,
+                // Detach child deadline if a null timeout is configured
+                deadlineEpochMS: params.timeoutMS === null || pctx?.workflowTimeoutMS === null ? undefined : wfctx.deadlineEpochMS,
+                enqueueOptions: params.enqueueOptions,
+            };
+            return await invokeRegOp(wfParams, wfctx.workflowUUID, funcId);
+        }
+        else {
+            // Else, we setup a parent context that includes all the potential metadata the application could have set in DBOSLocalCtx
+            let parentCtx = undefined;
+            if (pctx) {
+                // If pctx has no span, e.g., has not been setup through `withTracedContext`, set up a parent span for the workflow here.
+                const span = pctx.span ??
+                    DBOS.#executor.tracer.startSpan(pctx.operationCaller || 'workflowCaller', {
+                        operationUUID: wfId,
+                        operationType: pctx.operationType,
+                        authenticatedUser: pctx.authenticatedUser,
+                        assumedRole: pctx.assumedRole,
+                        authenticatedRoles: pctx.authenticatedRoles,
+                    });
+                parentCtx = new context_1.DBOSContextImpl(pctx.operationCaller || 'workflowCaller', span, DBOS.logger);
+                parentCtx.request = pctx.request ?? {};
+                parentCtx.authenticatedUser = pctx.authenticatedUser ?? '';
+                parentCtx.assumedRole = pctx.assumedRole ?? '';
+                parentCtx.authenticatedRoles = pctx.authenticatedRoles ?? [];
+                parentCtx.workflowUUID = wfId ?? '';
+            }
+            const wfParams = {
+                workflowUUID: wfId,
+                queueName,
+                enqueueOptions: params.enqueueOptions,
+                configuredInstance: instance,
+                parentCtx,
+                timeoutMS,
+            };
+            return await invokeRegOp(wfParams, undefined, undefined);
+        }
+        function invokeRegOp(wfParams, workflowID, funcNum) {
+            if (regOP.workflowConfig) {
+                const func = regOP.registeredFunction;
+                return dbos_executor_1.DBOSExecutor.globalInstance.internalWorkflow(func, wfParams, workflowID, funcNum, ...args);
+            }
+            if (regOP.txnConfig) {
+                const func = regOP.registeredFunction;
+                return dbos_executor_1.DBOSExecutor.globalInstance.startTransactionTempWF(func, wfParams, workflowID, funcNum, ...args);
+            }
+            if (regOP.stepConfig) {
+                const func = regOP.registeredFunction;
+                return dbos_executor_1.DBOSExecutor.globalInstance.startStepTempWF(func, wfParams, workflowID, funcNum, ...args);
+            }
+            throw new error_1.DBOSNotRegisteredError(regOP.name, `${regOP.name} is not a registered DBOS workflow, step, or transaction function`);
+        }
+    }
+    static #getWorkflowInvoker(registration, config) {
+        registration.setWorkflowConfig(config ?? {});
+        const invoker = async function (...rawArgs) {
+            const handle = await DBOS.#invokeWorkflow(this, registration, rawArgs);
+            return await handle.getResult();
+        };
+        (0, decorators_1.registerFunctionWrapper)(invoker, registration);
+        Object.defineProperty(invoker, 'name', {
+            value: registration.name,
+        });
+        return invoker;
+    }
     /**
      * Decorator designating a method as a DBOS transaction, making SQL clients available.
      *   A durable execution checkpoint will be applied to to the underlying database transaction
@@ -1340,7 +1298,7 @@ class DBOS {
                 }
                 else {
                     inst = this;
-                    if (!('name' in inst)) {
+                    if (!(inst instanceof _2.ConfiguredInstance)) {
                         throw new error_1.DBOSInvalidWorkflowTransitionError('Attempt to call a `transaction` function on an object that is not a `ConfiguredInstance`');
                     }
                 }
@@ -1466,7 +1424,7 @@ class DBOS {
                 }
                 else {
                     inst = this;
-                    if (!('name' in inst)) {
+                    if (!(inst instanceof _2.ConfiguredInstance)) {
                         throw new error_1.DBOSInvalidWorkflowTransitionError('Attempt to call a `step` function on an object that is not a `ConfiguredInstance`');
                     }
                 }
@@ -1519,6 +1477,65 @@ class DBOS {
         }
         return decorator;
     }
+    /**
+     * Create a check pointed DBOS step function from  a provided function
+     *   Similar to the DBOS.step decorator, but without requiring a decorator
+     *   A durable checkpoint will be made after the step completes
+     *   This ensures "at least once" execution of the step, and that the step will not
+     *    be executed again once the checkpoint is recorded
+     * @param func - The function to register as a step
+     * @param config - Configuration information for the step, particularly the retry policy
+     * @param config.name - The name of the step; if not provided, the function name will be used
+     */
+    static registerStep(func, config = {}) {
+        const name = config.name ?? func.name;
+        const invokeWrapper = async function (...rawArgs) {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const inst = this;
+            if (DBOS.isWithinWorkflow()) {
+                if (DBOS.isInTransaction()) {
+                    throw new error_1.DBOSInvalidWorkflowTransitionError('Invalid call to a `step` function from within a `transaction`');
+                }
+                if (DBOS.isInStep()) {
+                    // There should probably be checks here about the compatibility of the StepConfig...
+                    return func.call(this, ...rawArgs);
+                }
+                const wfctx = (0, context_1.assertCurrentWorkflowContext)();
+                return await dbos_executor_1.DBOSExecutor.globalInstance.callStepFunction(func, name, config, inst ?? null, wfctx, ...rawArgs);
+            }
+            if ((0, context_1.getNextWFID)(undefined)) {
+                throw new error_1.DBOSInvalidWorkflowTransitionError(`Invalid call to step '${name}' outside of a workflow; with directive to start a workflow.`);
+            }
+            return func.call(this, ...rawArgs);
+        };
+        Object.defineProperty(invokeWrapper, 'name', { value: name });
+        return invokeWrapper;
+    }
+    /**
+     * Run the enclosed `callback` as a checkpointed step within a DBOS workflow
+     * @param callback - function containing code to run
+     * @param config - Configuration information for the step, particularly the retry policy
+     * @param config.name - The name of the step; if not provided, the function name will be used
+     * @returns - result (either obtained from invoking function, or retrieved if run before)
+     */
+    static runStep(func, config = {}) {
+        const name = config.name ?? func.name;
+        if (DBOS.isWithinWorkflow()) {
+            if (DBOS.isInTransaction()) {
+                throw new error_1.DBOSInvalidWorkflowTransitionError('Invalid call to a runStep from within a `transaction`');
+            }
+            if (DBOS.isInStep()) {
+                // There should probably be checks here about the compatibility of the StepConfig...
+                return func();
+            }
+            const wfctx = (0, context_1.assertCurrentWorkflowContext)();
+            return dbos_executor_1.DBOSExecutor.globalInstance.callStepFunction(func, name, config, null, wfctx);
+        }
+        if ((0, context_1.getNextWFID)(undefined)) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError(`Invalid call to step '${name}' outside of a workflow; with directive to start a workflow.`);
+        }
+        return func();
+    }
     /** Decorator indicating that the method is the target of HTTP GET operations for `url` */
     static getApi(url) {
         return httpApiDec(handlerTypes_1.APITypes.GET, url);
@@ -1589,7 +1606,7 @@ class DBOS {
      * Register a middleware provider
      */
     static registerMiddlewareInstaller(mwp) {
-        (0, decorators_1.registerMiddlewareInserter)(mwp);
+        (0, decorators_1.registerMiddlewareInstaller)(mwp);
     }
     /**
      * Register information to be associated with a DBOS class