@dbos-inc/dbos-sdk 3.0.38-preview.g8bb2030562 → 3.0.43-preview

package/dist/src/dbos.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InitContext = exports.DBOS = exports.runInternalStep = exports.getExecutor = void 0;
 const context_1 = require("./context");
@@ -8,6 +11,7 @@ const logs_1 = require("./telemetry/logs");
 const error_1 = require("./error");
 const config_1 = require("./dbos-runtime/config");
 const runtime_1 = require("./dbos-runtime/runtime");
+const scheduler_1 = require("./scheduler/scheduler");
 const decorators_1 = require("./decorators");
 const utils_1 = require("./utils");
 const server_1 = require("./httpServer/server");
@@ -17,14 +21,13 @@ 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");
-const system_database_1 = require("./system_database");
 const wfqueue_1 = require("./wfqueue");
 const authdecorators_1 = require("./authdecorators");
+const node_assert_1 = __importDefault(require("node:assert"));
 function httpApiDec(verb, url) {
     return function apidec(target, propertyKey, inDescriptor) {
-        const { descriptor, registration } = (0, decorators_1.registerAndWrapDBOSFunction)(target, propertyKey, inDescriptor);
+        const { descriptor, registration } = (0, decorators_1.wrapDBOSFunctionAndRegisterDec)(target, propertyKey, inDescriptor);
         const handlerRegistration = registration;
         handlerRegistration.apiURL = url;
         handlerRegistration.apiType = verb;
@@ -62,53 +65,18 @@ class DBOS {
     static adminServer = undefined;
     static appServer = undefined;
     static conductor = undefined;
-    static getDebugModeFromEnv() {
-        const debugWorkflowId = process.env.DBOS_DEBUG_WORKFLOW_ID;
-        return debugWorkflowId !== undefined;
-    }
     /**
      * Set configuration of `DBOS` prior to `launch`
      * @param config - configuration of services needed by DBOS
-     * @param runtimeConfig - configuration of runtime access to DBOS
      */
-    static setConfig(config, runtimeConfig) {
+    static setConfig(config) {
+        (0, node_assert_1.default)(!DBOS.isInitialized(), 'Cannot call DBOS.setConfig after DBOS.launch');
         DBOS.#dbosConfig = config;
-        DBOS.#runtimeConfig = runtimeConfig;
-        DBOS.translateConfig();
-    }
-    static translateConfig() {
-        if (DBOS.#dbosConfig && !(0, dbos_executor_1.isDeprecatedDBOSConfig)(DBOS.#dbosConfig)) {
-            const debugMode = DBOS.getDebugModeFromEnv();
-            [DBOS.#dbosConfig, DBOS.#runtimeConfig] = (0, config_1.translatePublicDBOSconfig)(DBOS.#dbosConfig, debugMode);
-            if (process.env.DBOS__CLOUD === 'true') {
-                [DBOS.#dbosConfig, DBOS.#runtimeConfig] = (0, config_1.overwrite_config)(DBOS.#dbosConfig, DBOS.#runtimeConfig);
-            }
-        }
-    }
-    /**
-     * @deprecated For unit testing purposes only
-     *   Use `setConfig`
-     */
-    static setAppConfig(key, newValue) {
-        const conf = DBOS.#dbosConfig?.application;
-        if (!conf)
-            throw new error_1.DBOSExecutorNotInitializedError();
-        (0, lodash_1.set)(conf, key, newValue);
-    }
-    /**
-     * Drop DBOS system database.
-     * USE IN TESTS ONLY - ALL WORKFLOWS, QUEUES, ETC. WILL BE LOST.
-     */
-    static async dropSystemDB() {
-        if (!DBOS.#dbosConfig) {
-            DBOS.#dbosConfig = (0, config_1.parseConfigFile)()[0];
-        }
-        DBOS.translateConfig();
-        return system_database_1.PostgresSystemDatabase.dropSystemDB(DBOS.#dbosConfig);
     }
     /**
      * Use ORMEntities to set up database schema.
      * Only relevant for TypeORM, and for testing purposes only, not production
+     * @deprecated - use data source packages such as `@dbos-inc/typeorm-datasource`
      */
     static async createUserSchema() {
         return dbos_executor_1.DBOSExecutor.globalInstance?.userDatabase.createSchema();
@@ -116,6 +84,7 @@ class DBOS {
     /**
      * Use ORMEntities to drop database schema.
      * Only relevant for TypeORM, and for testing purposes only, not production
+     * @deprecated - use data source packages such as `@dbos-inc/typeorm-datasource`
      */
     static async dropUserSchema() {
         return dbos_executor_1.DBOSExecutor.globalInstance?.userDatabase.dropSchema();
@@ -141,25 +110,55 @@ class DBOS {
         if (DBOS.isInitialized()) {
             return;
         }
-        const debugMode = options?.debugMode ?? DBOS.getDebugModeFromEnv();
         if (options?.conductorKey) {
             // Use a generated executor ID.
             utils_1.globalParams.executorID = (0, node_crypto_1.randomUUID)();
         }
-        // Initialize the DBOS executor
-        if (!DBOS.#dbosConfig) {
-            [DBOS.#dbosConfig, DBOS.#runtimeConfig] = (0, config_1.parseConfigFile)({ forceConsole: debugMode });
-        }
-        else if (!(0, dbos_executor_1.isDeprecatedDBOSConfig)(DBOS.#dbosConfig)) {
-            DBOS.translateConfig(); // This is a defensive measure for users who'd do DBOS.config = X instead of using DBOS.setConfig()
-        }
-        if (!DBOS.#dbosConfig) {
-            throw new error_1.DBOSError('DBOS configuration not set');
+        const debugMode = options?.debugMode ?? process.env.DBOS_DEBUG_WORKFLOW_ID !== undefined;
+        const configFile = (0, config_1.readConfigFile)();
+        const $dbosConfig = DBOS.#dbosConfig;
+        let [internalConfig, runtimeConfig] = $dbosConfig
+            ? (0, config_1.translatePublicDBOSconfig)(
+            // copy config settings to ensure no unexpected fields are passed thru
+            {
+                adminPort: $dbosConfig.adminPort,
+                name: $dbosConfig.name,
+                databaseUrl: $dbosConfig.databaseUrl,
+                userDbclient: $dbosConfig.userDbclient,
+                userDbPoolSize: $dbosConfig.userDbPoolSize,
+                sysDbName: $dbosConfig.sysDbName,
+                sysDbPoolSize: $dbosConfig.sysDbPoolSize,
+                logLevel: $dbosConfig.logLevel,
+                addContextMetadata: $dbosConfig.addContextMetadata,
+                runAdminServer: $dbosConfig.runAdminServer,
+                otlpTracesEndpoints: [...($dbosConfig.otlpTracesEndpoints ?? [])],
+                otlpLogsEndpoints: [...($dbosConfig.otlpLogsEndpoints ?? [])],
+            }, debugMode)
+            : (0, config_1.processConfigFile)(configFile, { forceConsole: debugMode });
+        if (process.env.DBOS__CLOUD === 'true') {
+            [internalConfig, runtimeConfig] = (0, config_1.overwrite_config)(internalConfig, runtimeConfig, configFile);
+        }
+        DBOS.#port = runtimeConfig.port;
+        DBOS.#poolConfig = internalConfig.poolConfig;
+        DBOS.#dbosConfig = {
+            name: internalConfig.name,
+            databaseUrl: internalConfig.databaseUrl,
+            userDbclient: internalConfig.userDbclient,
+            userDbPoolSize: DBOS.#dbosConfig?.userDbPoolSize,
+            sysDbName: internalConfig.system_database,
+            sysDbPoolSize: internalConfig.sysDbPoolSize,
+            logLevel: internalConfig.telemetry.logs?.logLevel,
+            addContextMetadata: internalConfig.telemetry.logs?.addContextMetadata,
+            otlpTracesEndpoints: [...(internalConfig.telemetry.OTLPExporter?.tracesEndpoint ?? [])],
+            otlpLogsEndpoints: [...(internalConfig.telemetry.OTLPExporter?.logsEndpoint ?? [])],
+            adminPort: runtimeConfig.admin_port,
+            runAdminServer: runtimeConfig.runAdminServer,
+        };
+        if (utils_1.globalParams.appName === '' && DBOS.#dbosConfig.name) {
+            utils_1.globalParams.appName = DBOS.#dbosConfig.name;
         }
         dbos_executor_1.DBOSExecutor.createInternalQueue();
-        dbos_executor_1.DBOSExecutor.globalInstance = new dbos_executor_1.DBOSExecutor(DBOS.#dbosConfig, {
-            debugMode,
-        });
+        dbos_executor_1.DBOSExecutor.globalInstance = new dbos_executor_1.DBOSExecutor(internalConfig, { debugMode });
         const executor = dbos_executor_1.DBOSExecutor.globalInstance;
         await executor.init();
         const debugWorkflowId = process.env.DBOS_DEBUG_WORKFLOW_ID;
@@ -186,14 +185,14 @@ class DBOS {
         }
         // Start the DBOS admin server
         const logger = DBOS.logger;
-        if (DBOS.#runtimeConfig && DBOS.#runtimeConfig.runAdminServer) {
+        if (runtimeConfig.runAdminServer) {
             const adminApp = server_1.DBOSHttpServer.setupAdminApp(executor);
             try {
-                await server_1.DBOSHttpServer.checkPortAvailabilityIPv4Ipv6(DBOS.#runtimeConfig.admin_port, logger);
+                await server_1.DBOSHttpServer.checkPortAvailabilityIPv4Ipv6(runtimeConfig.admin_port, logger);
                 // Wrap the listen call in a promise to properly catch errors
                 DBOS.adminServer = await new Promise((resolve, reject) => {
-                    const server = adminApp.listen(DBOS.#runtimeConfig?.admin_port, () => {
-                        DBOS.logger.debug(`DBOS Admin Server is running at http://localhost:${DBOS.#runtimeConfig?.admin_port}`);
+                    const server = adminApp.listen(runtimeConfig?.admin_port, () => {
+                        DBOS.logger.debug(`DBOS Admin Server is running at http://localhost:${runtimeConfig?.admin_port}`);
                         resolve(server);
                     });
                     server.on('error', (err) => {
@@ -202,7 +201,7 @@ class DBOS {
                 });
             }
             catch (e) {
-                logger.warn(`Unable to start DBOS admin server on port ${DBOS.#runtimeConfig.admin_port}`);
+                logger.warn(`Unable to start DBOS admin server on port ${runtimeConfig.admin_port}`);
             }
         }
         if (options?.koaApp) {
@@ -242,7 +241,6 @@ class DBOS {
         if (!dbos_executor_1.DBOSExecutor.globalInstance)
             return;
         dbos_executor_1.DBOSExecutor.globalInstance.logRegisteredHTTPUrls();
-        dbos_executor_1.DBOSExecutor.globalInstance.scheduler?.logRegisteredSchedulerEndpoints();
         wfqueue_1.wfQueueRunner.logRegisteredEndpoints(dbos_executor_1.DBOSExecutor.globalInstance);
         for (const lcl of (0, decorators_1.getLifecycleListeners)()) {
             lcl.logRegisteredEndpoints?.();
@@ -305,6 +303,7 @@ class DBOS {
      * Creates a node.js HTTP handler for all entrypoints registered with `@DBOS.getApi`
      * and other decorators.  The handler can be retrieved with `DBOS.getHTTPHandlersCallback()`.
      * This method does not start listening for requests.  For that, call `DBOS.launchAppHTTPServer()`.
+     * @deprecated - use `@dbos-inc/koa-serve`
      */
     static setUpHandlerCallback() {
         if (!dbos_executor_1.DBOSExecutor.globalInstance) {
@@ -319,12 +318,13 @@ class DBOS {
      * Creates a node.js HTTP handler for all entrypoints registered with `@DBOS.getApi`
      * and other decorators.  This method also starts listening for requests, on the port
      * specified in the `DBOSRuntimeConfig`.
+     * @deprecated - use `@dbos-inc/koa-serve`
      */
     static async launchAppHTTPServer() {
         const server = DBOS.setUpHandlerCallback();
-        if (DBOS.#runtimeConfig) {
+        if (DBOS.#port) {
             // This will not listen if there's no decorated endpoint
-            DBOS.appServer = await server.appListen(DBOS.#runtimeConfig.port);
+            DBOS.appServer = await server.appListen(DBOS.#port);
         }
     }
     /**
@@ -332,6 +332,7 @@ class DBOS {
      *  (This is the one that handles the @DBOS.getApi, etc., methods.)
      *   Useful for testing purposes, or to combine the DBOS service with other
      *   node.js HTTP server frameworks.
+     * @deprecated - use `@dbos-inc/koa-serve`
      */
     static getHTTPHandlersCallback() {
         if (!server_1.DBOSHttpServer.instance) {
@@ -350,9 +351,10 @@ class DBOS {
     // Globals
     //////
     static #dbosConfig;
-    static #runtimeConfig = undefined;
+    static #poolConfig;
+    static #port;
     static get dbosConfig() {
-        return DBOS.#dbosConfig;
+        return { ...DBOS.#dbosConfig, poolConfig: DBOS.#poolConfig };
     }
     //////
     // Context
@@ -396,11 +398,17 @@ class DBOS {
             throw new error_1.DBOSError('`DBOS.request` accessed from outside of HTTP requests');
         return r;
     }
-    /** Get the current Koa context (within `@DBOS.getApi` et al) */
+    /**
+     * Get the current Koa context (within `@DBOS.getApi` et al)
+     * @deprecated - use `@dbos-inc/koa-serve`
+     */
     static getKoaContext() {
         return (0, context_1.getCurrentContextStore)()?.koaContext;
     }
-    /** Get the current Koa context (within `@DBOS.getApi` et al) */
+    /**
+     * Get the current Koa context (within `@DBOS.getApi` et al)
+     * @deprecated - use `@dbos-inc/koa-serve`
+     */
     static get koaContext() {
         const r = DBOS.getKoaContext();
         if (!r)
@@ -466,7 +474,16 @@ class DBOS {
         return DBOS.isWithinWorkflow() && !DBOS.isInTransaction() && !DBOS.isInStep() && !DBOS.isInStoredProc();
     }
     // sql session (various forms)
-    /** @returns the current SQL client; only allowed within `@DBOS.transaction` functions */
+    /**
+     * @returns the current SQL client; only allowed within `@DBOS.transaction` functions
+     * @deprecated - use data source packages such as:
+     *  `@dbos-inc/drizzle-datasource`
+     *  `@dbos-inc/knex-datasource`
+     *  `@dbos-inc/node-pg-datasource`
+     *  `@dbos-inc/postgres-datasource`
+     *  `@dbos-inc/prisma-datasource`
+     *  `@dbos-inc/typeorm-datasource`
+     */
     static get sqlClient() {
         const c = (0, context_1.getCurrentContextStore)()?.sqlClient;
         if (!DBOS.isInTransaction() || !c)
@@ -476,6 +493,7 @@ class DBOS {
     /**
      * @returns the current PG SQL client;
      *  only allowed within `@DBOS.transaction` functions when a `PGNODE` user database is in use
+     * @deprecated - use data source packages such as `@dbos-inc/node-pg-datasource`
      */
     static get pgClient() {
         const client = DBOS.sqlClient;
@@ -487,6 +505,7 @@ class DBOS {
     /**
      * @returns the current Knex SQL client;
      *  only allowed within `@DBOS.transaction` functions when a `KNEX` user database is in use
+     * @deprecated - use `@dbos-inc/knex-datasource` package
      */
     static get knexClient() {
         if (DBOS.isInStoredProc()) {
@@ -501,6 +520,7 @@ class DBOS {
     /**
      * @returns the current Prisma SQL client;
      *  only allowed within `@DBOS.transaction` functions when a `PRISMA` user database is in use
+     * @deprecated - use `@dbos-inc/prisma-datasource` package
      */
     static get prismaClient() {
         if (DBOS.isInStoredProc()) {
@@ -515,6 +535,7 @@ class DBOS {
     /**
      * @returns the current  TypeORM SQL client;
      *  only allowed within `@DBOS.transaction` functions when the `TYPEORM` user database is in use
+     * @deprecated - use `@dbos-inc/typeorm-datasource` package
      */
     static get typeORMClient() {
         if (DBOS.isInStoredProc()) {
@@ -529,6 +550,7 @@ class DBOS {
     /**
      * @returns the current Drizzle SQL client;
      *  only allowed within `@DBOS.transaction` functions when the `DRIZZLE` user database is in use
+     * @deprecated - use `@dbos-inc/drizzle-datasource` package
      */
     static get drizzleClient() {
         if (DBOS.isInStoredProc()) {
@@ -540,23 +562,19 @@ class DBOS {
         const client = DBOS.sqlClient;
         return client;
     }
-    /**
-     * Gets configuration information from the `application` section
-     *  of `DBOSConfig`
-     * @param key - name of configuration item
-     * @param defaultValue - value to return if `key` does not exist in the configuration
-     */
-    static getConfig(key, defaultValue) {
-        if (DBOS.#executor)
-            return DBOS.#executor.getConfig(key, defaultValue);
-        return defaultValue;
-    }
     /**
      * Query the current application database
      * @param sql - parameterized SQL statement (string) to execute
      * @param params - parameter values for `sql`
      * @template T - Type for the returned records
      * @returns Array of records returned by the SQL statement
+     * @deprecated - use data source packages such as:
+     *  `@dbos-inc/drizzle-datasource`
+     *  `@dbos-inc/knex-datasource`
+     *  `@dbos-inc/node-pg-datasource`
+     *  `@dbos-inc/postgres-datasource`
+     *  `@dbos-inc/prisma-datasource`
+     *  `@dbos-inc/typeorm-datasource`
      */
     static async queryUserDB(sql, params) {
         if (DBOS.isWithinWorkflow() && !DBOS.isInStep()) {
@@ -1033,21 +1051,33 @@ class DBOS {
         }
         return DBOS.#executor.getEvent(workflowID, key, timeoutSeconds);
     }
+    /**
+     * registers a workflow method or function with an invocation schedule
+     * @param func - The workflow method or function to register with an invocation schedule
+     * @param options - Configuration information for the scheduled workflow
+     */
+    static registerScheduled(func, config) {
+        scheduler_1.ScheduledReceiver.registerScheduled(func, config);
+    }
     //////
     // Decorators
     //////
     /**
      * Decorator associating a class static method with an invocation schedule
-     * @param schedulerConfig - The schedule, consisting of a crontab and policy for "make-up work"
+     * @param config - The schedule, consisting of a crontab and policy for "make-up work"
      */
-    static scheduled(schedulerConfig) {
-        function scheddec(target, propertyKey, inDescriptor) {
-            const { descriptor, registration } = (0, decorators_1.registerAndWrapDBOSFunction)(target, propertyKey, inDescriptor);
-            const schedRegistration = registration;
-            schedRegistration.schedulerConfig = schedulerConfig;
+    static scheduled(config) {
+        function methodDecorator(target, propertyKey, descriptor) {
+            if (descriptor.value) {
+                DBOS.registerScheduled(descriptor.value, {
+                    ...config,
+                    ctorOrProto: target,
+                    name: String(propertyKey),
+                });
+            }
             return descriptor;
         }
-        return scheddec;
+        return methodDecorator;
     }
     /**
      * Decorator designating a method as a DBOS workflow
@@ -1057,10 +1087,11 @@ class DBOS {
      */
     static workflow(config = {}) {
         function decorator(target, propertyKey, inDescriptor) {
-            const { descriptor, registration } = (0, decorators_1.registerAndWrapDBOSFunction)(target, propertyKey, inDescriptor);
+            const { descriptor, registration } = (0, decorators_1.wrapDBOSFunctionAndRegisterByUniqueNameDec)(target, propertyKey, inDescriptor);
             const invoker = DBOS.#getWorkflowInvoker(registration, config);
             descriptor.value = invoker;
             registration.wrappedFunction = invoker;
+            (0, decorators_1.registerFunctionWrapper)(invoker, registration);
             return descriptor;
         }
         return decorator;
@@ -1074,9 +1105,9 @@ class DBOS {
      * @param name - The name of the registered workflow
      * @param options - Configuration information for the registered workflow
      */
-    static registerWorkflow(func, options = {}) {
-        const { registration } = (0, decorators_1.registerAndWrapDBOSFunctionByName)(options.ctorOrProto, options.className, options.name ?? func.name, func);
-        return DBOS.#getWorkflowInvoker(registration, options.config);
+    static registerWorkflow(func, config) {
+        const registration = (0, decorators_1.wrapDBOSFunctionAndRegisterByUniqueName)(config?.ctorOrProto, config?.className, config?.name ?? func.name, func);
+        return DBOS.#getWorkflowInvoker(registration, config);
     }
     static async #invokeWorkflow($this, regOP, args, params = {}) {
         const wfId = (0, context_1.getNextWFID)(params.workflowID);
@@ -1163,10 +1194,17 @@ class DBOS {
      *   A durable execution checkpoint will be applied to to the underlying database transaction
      * @see `DBOS.sqlClient`
      * @param config - Configuration information for the transaction, particularly its isolation mode
+     * @deprecated - use data source packages such as:
+     *  `@dbos-inc/drizzle-datasource`
+     *  `@dbos-inc/knex-datasource`
+     *  `@dbos-inc/node-pg-datasource`
+     *  `@dbos-inc/postgres-datasource`
+     *  `@dbos-inc/prisma-datasource`
+     *  `@dbos-inc/typeorm-datasource`
      */
     static transaction(config = {}) {
         function decorator(target, propertyKey, inDescriptor) {
-            const { descriptor, registration } = (0, decorators_1.registerAndWrapDBOSFunction)(target, propertyKey, inDescriptor);
+            const { descriptor, registration } = (0, decorators_1.wrapDBOSFunctionAndRegisterByUniqueNameDec)(target, propertyKey, inDescriptor);
             registration.setTxnConfig(config);
             const invokeWrapper = async function (...rawArgs) {
                 let inst = undefined;
@@ -1208,6 +1246,7 @@ class DBOS {
             };
             descriptor.value = invokeWrapper;
             registration.wrappedFunction = invokeWrapper;
+            (0, decorators_1.registerFunctionWrapper)(invokeWrapper, registration);
             Object.defineProperty(invokeWrapper, 'name', {
                 value: registration.name,
             });
@@ -1223,7 +1262,7 @@ class DBOS {
      */
     static storedProcedure(config = {}) {
         function decorator(target, propertyKey, inDescriptor) {
-            const { descriptor, registration } = (0, decorators_1.registerAndWrapDBOSFunction)(target, propertyKey, inDescriptor);
+            const { descriptor, registration } = (0, decorators_1.wrapDBOSFunctionAndRegisterByUniqueNameDec)(target, propertyKey, inDescriptor);
             registration.setProcConfig(config);
             const invokeWrapper = async function (...rawArgs) {
                 if (typeof this !== 'function') {
@@ -1251,6 +1290,7 @@ class DBOS {
             };
             descriptor.value = invokeWrapper;
             registration.wrappedFunction = invokeWrapper;
+            (0, decorators_1.registerFunctionWrapper)(invokeWrapper, registration);
             Object.defineProperty(invokeWrapper, 'name', {
                 value: registration.name,
             });
@@ -1268,7 +1308,7 @@ class DBOS {
      */
     static step(config = {}) {
         function decorator(target, propertyKey, inDescriptor) {
-            const { descriptor, registration } = (0, decorators_1.registerAndWrapDBOSFunction)(target, propertyKey, inDescriptor);
+            const { descriptor, registration } = (0, decorators_1.wrapDBOSFunctionAndRegisterByUniqueNameDec)(target, propertyKey, inDescriptor);
             registration.setStepConfig(config);
             const invokeWrapper = async function (...rawArgs) {
                 let inst = undefined;
@@ -1311,6 +1351,7 @@ class DBOS {
             };
             descriptor.value = invokeWrapper;
             registration.wrappedFunction = invokeWrapper;
+            (0, decorators_1.registerFunctionWrapper)(invokeWrapper, registration);
             Object.defineProperty(invokeWrapper, 'name', {
                 value: registration.name,
             });
@@ -1325,29 +1366,31 @@ class DBOS {
      *   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
+     * @param config - Configuration information for the step, particularly the retry policy and name
      */
     static registerStep(func, config = {}) {
         const name = config.name ?? func.name;
+        const reg = (0, decorators_1.wrapDBOSFunctionAndRegister)(config?.ctorOrProto, config?.className, name, func);
         const invokeWrapper = async function (...rawArgs) {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const inst = this;
+            const callFunc = reg.registeredFunction ?? reg.origFunction;
             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);
+                    return callFunc.call(this, ...rawArgs);
                 }
-                return await dbos_executor_1.DBOSExecutor.globalInstance.callStepFunction(func, name, config, inst ?? null, ...rawArgs);
+                return await dbos_executor_1.DBOSExecutor.globalInstance.callStepFunction(callFunc, name, config, inst ?? null, ...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);
+            return callFunc.call(this, ...rawArgs);
         };
+        (0, decorators_1.registerFunctionWrapper)(invokeWrapper, reg);
         Object.defineProperty(invokeWrapper, 'name', { value: name });
         return invokeWrapper;
     }
@@ -1375,23 +1418,38 @@ class DBOS {
         }
         return func();
     }
-    /** Decorator indicating that the method is the target of HTTP GET operations for `url` */
+    /**
+     * Decorator indicating that the method is the target of HTTP GET operations for `url`
+     * @deprecated - use `@dbos-inc/koa-serve`
+     */
     static getApi(url) {
         return httpApiDec(handlerTypes_1.APITypes.GET, url);
     }
-    /** Decorator indicating that the method is the target of HTTP POST operations for `url` */
+    /**
+     * Decorator indicating that the method is the target of HTTP POST operations for `url`
+     * @deprecated - use `@dbos-inc/koa-serve`
+     */
     static postApi(url) {
         return httpApiDec(handlerTypes_1.APITypes.POST, url);
     }
-    /** Decorator indicating that the method is the target of HTTP PUT operations for `url` */
+    /**
+     * Decorator indicating that the method is the target of HTTP PUT operations for `url`
+     * @deprecated - use `@dbos-inc/koa-serve`
+     */
     static putApi(url) {
         return httpApiDec(handlerTypes_1.APITypes.PUT, url);
     }
-    /** Decorator indicating that the method is the target of HTTP PATCH operations for `url` */
+    /**
+     * Decorator indicating that the method is the target of HTTP PATCH operations for `url`
+     * @deprecated - use `@dbos-inc/koa-serve`
+     */
     static patchApi(url) {
         return httpApiDec(handlerTypes_1.APITypes.PATCH, url);
     }
-    /** Decorator indicating that the method is the target of HTTP DELETE operations for `url` */
+    /**
+     * Decorator indicating that the method is the target of HTTP DELETE operations for `url`
+     * @deprecated - use `@dbos-inc/koa-serve`
+     */
     static deleteApi(url) {
         return httpApiDec(handlerTypes_1.APITypes.DELETE, url);
     }
@@ -1449,13 +1507,13 @@ class DBOS {
      * Register information to be associated with a DBOS function
      */
     static associateFunctionWithInfo(external, func, target) {
-        return (0, decorators_1.associateMethodWithExternal)(external, target.ctorOrProto, target.className, target.name, func);
+        return (0, decorators_1.associateMethodWithExternal)(external, target.ctorOrProto, target.className, target.name ?? func.name, func);
     }
     /**
      * Register information to be associated with a DBOS function
      */
     static associateParamWithInfo(external, func, target) {
-        return (0, decorators_1.associateParameterWithExternal)(external, target.ctorOrProto, target.className, target.name, func, target.param);
+        return (0, decorators_1.associateParameterWithExternal)(external, target.ctorOrProto, target.className, target.name ?? func.name, func, target.param);
     }
     /** Get registrations */
     static getAssociatedInfo(external, cls, funcName) {
@@ -1476,14 +1534,6 @@ class InitContext {
     queryUserDB(sql, ...params) {
         return DBOS.queryUserDB(sql, params);
     }
-    getConfig(key, defaultValue) {
-        const value = DBOS.getConfig(key, defaultValue);
-        // If the key is found and the default value is provided, check whether the value is of the same type.
-        if (value && defaultValue && typeof value !== typeof defaultValue) {
-            throw new error_1.DBOSConfigKeyTypeError(key, typeof defaultValue, typeof value);
-        }
-        return value;
-    }
 }
 exports.InitContext = InitContext;
 //# sourceMappingURL=dbos.js.map