@dbos-inc/dbos-sdk 3.5.44-preview.gc094fdab44 → 3.6.3-preview

package/dist/src/dbos.js

@@ -3,25 +3,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DBOS = exports.runInternalStep = 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 traces_1 = require("./telemetry/traces");
 const workflow_1 = require("./workflow");
 const logs_1 = require("./telemetry/logs");
 const error_1 = require("./error");
-const config_1 = require("./config");
+const config_1 = require("./dbos-runtime/config");
 const scheduler_1 = require("./scheduler/scheduler");
 const decorators_1 = require("./decorators");
 const utils_1 = require("./utils");
-const adminserver_1 = require("./adminserver");
+const server_1 = require("./httpServer/server");
+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 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"));
 const api_1 = require("@opentelemetry/api");
+function httpApiDec(verb, url) {
+    return function apidec(target, propertyKey, inDescriptor) {
+        const { descriptor, registration } = (0, decorators_1.wrapDBOSFunctionAndRegisterDec)(target, propertyKey, inDescriptor);
+        const handlerRegistration = registration;
+        handlerRegistration.apiURL = url;
+        handlerRegistration.apiType = verb;
+        (0, _1.requestArgValidation)(registration);
+        return descriptor;
+    };
+}
 function getExecutor() {
     if (!dbos_executor_1.DBOSExecutor.globalInstance) {
         throw new error_1.DBOSExecutorNotInitializedError();
@@ -50,6 +64,7 @@ class DBOS {
     // Lifecycle
     ///////
     static adminServer = undefined;
+    static appServer = undefined;
     static conductor = undefined;
     /**
      * Set configuration of `DBOS` prior to `launch`
@@ -59,6 +74,26 @@ class DBOS {
         (0, node_assert_1.default)(!DBOS.isInitialized(), 'Cannot call DBOS.setConfig after DBOS.launch');
         DBOS.#dbosConfig = config;
     }
+    /**
+     * 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?.createUserSchema();
+    }
+    /**
+     * 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?.dropUserSchema();
+    }
+    // Load files with DBOS classes (running their decorators)
+    static async loadClasses(dbosEntrypointFiles) {
+        return await dbos_executor_1.DBOSExecutor.loadClasses(dbosEntrypointFiles);
+    }
     /**
      * Check if DBOS has been `launch`ed (and not `shutdown`)
      * @returns `true` if DBOS has been launched, or `false` otherwise
@@ -99,6 +134,7 @@ class DBOS {
             [internalConfig, runtimeConfig] = (0, config_1.overwriteConfigForDBOSCloud)(internalConfig, runtimeConfig, configFile);
         }
         DBOS.#port = runtimeConfig.port;
+        DBOS.#userDbClient = internalConfig.userDbClient;
         dbos_executor_1.DBOSExecutor.createDebouncerWorkflow();
         dbos_executor_1.DBOSExecutor.createInternalQueue();
         dbos_executor_1.DBOSExecutor.globalInstance = new dbos_executor_1.DBOSExecutor(internalConfig, { debugMode });
@@ -130,9 +166,9 @@ class DBOS {
         // Start the DBOS admin server
         const logger = DBOS.logger;
         if (runtimeConfig.runAdminServer) {
-            const adminApp = adminserver_1.DBOSAdminServer.setupAdminApp(executor);
+            const adminApp = server_1.DBOSHttpServer.setupAdminApp(executor);
             try {
-                await adminserver_1.DBOSAdminServer.checkPortAvailabilityIPv4Ipv6(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(runtimeConfig?.admin_port, () => {
@@ -159,6 +195,7 @@ class DBOS {
     static logRegisteredEndpoints() {
         if (!dbos_executor_1.DBOSExecutor.globalInstance)
             return;
+        dbos_executor_1.DBOSExecutor.globalInstance.logRegisteredHTTPUrls();
         wfqueue_1.wfQueueRunner.logRegisteredEndpoints(dbos_executor_1.DBOSExecutor.globalInstance);
         for (const lcl of (0, decorators_1.getLifecycleListeners)()) {
             lcl.logRegisteredEndpoints?.();
@@ -171,6 +208,11 @@ class DBOS {
      *   Stops workflow processing and disconnects from databases
      */
     static async shutdown() {
+        // Stop the app server
+        if (DBOS.appServer) {
+            DBOS.appServer.close();
+            DBOS.appServer = undefined;
+        }
         // Stop the admin server
         if (DBOS.adminServer) {
             DBOS.adminServer.close();
@@ -212,18 +254,60 @@ class DBOS {
     static get #executor() {
         return getExecutor();
     }
+    /**
+     * 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) {
+            throw new error_1.DBOSExecutorNotInitializedError();
+        }
+        // Create the DBOS HTTP server
+        //  This may be a no-op if there are no registered endpoints
+        const server = new server_1.DBOSHttpServer(dbos_executor_1.DBOSExecutor.globalInstance);
+        return server;
+    }
+    /**
+     * 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.#port) {
+            // This will not listen if there's no decorated endpoint
+            DBOS.appServer = await server.appListen(DBOS.#port);
+        }
+    }
+    /**
+     * Retrieves the HTTP handlers callback for DBOS HTTP.
+     *  (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) {
+            return undefined;
+        }
+        return server_1.DBOSHttpServer.instance.app.callback();
+    }
     /** For unit testing of admin server (do not call) */
     static getAdminCallback() {
-        if (!adminserver_1.DBOSAdminServer.instance) {
+        if (!server_1.DBOSHttpServer.instance) {
             return undefined;
         }
-        return adminserver_1.DBOSAdminServer.instance.adminApp.callback();
+        return server_1.DBOSHttpServer.instance.adminApp.callback();
     }
     //////
     // Globals
     //////
     static #dbosConfig;
     static #port;
+    static #userDbClient;
     //////
     // Context
     //////
@@ -266,6 +350,27 @@ 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)
+     * @deprecated - use `@dbos-inc/koa-serve`
+     */
+    static getKoaContext() {
+        return (0, context_1.getCurrentContextStore)()?.koaContext;
+    }
+    /**
+     * 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)
+            throw new error_1.DBOSError('`DBOS.koaContext` accessed from outside koa request');
+        return r;
+    }
+    /** Get the current application version */
+    static get applicationVersion() {
+        return utils_1.globalParams.appVersion;
+    }
     /** Get the current workflow ID */
     static get workflowID() {
         return (0, context_1.getCurrentContextStore)()?.workflowId;
@@ -301,6 +406,10 @@ class DBOS {
     static isInTransaction() {
         return (0, context_1.getCurrentContextStore)()?.curTxFunctionId !== undefined;
     }
+    /** @returns true if called from within a stored procedure, false otherwise */
+    static isInStoredProc() {
+        return (0, context_1.getCurrentContextStore)()?.isInStoredProc ?? false;
+    }
     /** @returns true if called from within a step, false otherwise */
     static isInStep() {
         return (0, context_1.getCurrentContextStore)()?.curStepFunctionId !== undefined;
@@ -318,7 +427,111 @@ class DBOS {
      *  a step, transaction, or procedure, or false otherwise
      */
     static isInWorkflow() {
-        return DBOS.isWithinWorkflow() && !DBOS.isInTransaction() && !DBOS.isInStep();
+        return DBOS.isWithinWorkflow() && !DBOS.isInTransaction() && !DBOS.isInStep() && !DBOS.isInStoredProc();
+    }
+    // sql session (various forms)
+    /**
+     * @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)
+            throw new error_1.DBOSInvalidWorkflowTransitionError('Invalid use of `DBOS.sqlClient` outside of a `transaction`');
+        return c;
+    }
+    /**
+     * @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() {
+        if (!DBOS.isInStoredProc() && DBOS.#userDbClient !== user_database_1.UserDatabaseName.PGNODE) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError(`Requested 'DBOS.pgClient' but client is configured with type '${DBOS.#userDbClient}'`);
+        }
+        return DBOS.sqlClient;
+    }
+    /**
+     * @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()) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError(`Requested 'DBOS.knexClient' from within a stored procedure`);
+        }
+        if (DBOS.#userDbClient !== user_database_1.UserDatabaseName.KNEX) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError(`Requested 'DBOS.knexClient' but client is configured with type '${DBOS.#userDbClient}'`);
+        }
+        return DBOS.sqlClient;
+    }
+    /**
+     * @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()) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError(`Requested 'DBOS.prismaClient' from within a stored procedure`);
+        }
+        if (DBOS.#userDbClient !== user_database_1.UserDatabaseName.PRISMA) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError(`Requested 'DBOS.prismaClient' but client is configured with type '${DBOS.#userDbClient}'`);
+        }
+        return DBOS.sqlClient;
+    }
+    /**
+     * @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()) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError(`Requested 'DBOS.typeORMClient' from within a stored procedure`);
+        }
+        if (DBOS.#userDbClient !== user_database_1.UserDatabaseName.TYPEORM) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError(`Requested 'DBOS.typeORMClient' but client is configured with type '${DBOS.#userDbClient}'`);
+        }
+        return DBOS.sqlClient;
+    }
+    /**
+     * @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()) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError(`Requested 'DBOS.drizzleClient' from within a stored procedure`);
+        }
+        if (DBOS.#userDbClient !== user_database_1.UserDatabaseName.DRIZZLE) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError(`Requested 'DBOS.drizzleClient' but client is configured with type '${DBOS.#userDbClient}'`);
+        }
+        return DBOS.sqlClient;
+    }
+    /**
+     * 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()) {
+            throw new error_1.DBOSInvalidWorkflowTransitionError('Invalid call to `queryUserDB` inside a `workflow`, without being in a `step`');
+        }
+        return DBOS.#executor.queryUserDB(sql, params);
     }
     //////
     // Access to system DB, for event receivers etc.
@@ -421,6 +634,19 @@ class DBOS {
         }
         return DBOS.#executor.retrieveWorkflow(workflowID);
     }
+    /**
+     * Query the system database for all workflows matching the provided predicate
+     * @param input - `GetWorkflowsInput` predicate for filtering returned workflows
+     * @returns `GetWorkflowsOutput` listing the workflow IDs of matching workflows
+     * @deprecated Use `DBOS.listWorkflows` instead
+     */
+    static async getWorkflows(input) {
+        (0, decorators_1.ensureDBOSIsLaunched)('getWorkflows');
+        return await runInternalStep(async () => {
+            const wfs = await DBOS.#executor.listWorkflows(input);
+            return { workflowUUIDs: wfs.map((wf) => wf.workflowID) };
+        }, 'DBOS.getWorkflows');
+    }
     /**
      * Query the system database for all workflows matching the provided predicate
      * @param input - `GetWorkflowsInput` predicate for filtering returned workflows
@@ -610,6 +836,17 @@ class DBOS {
         (0, decorators_1.ensureDBOSIsLaunched)('tracing');
         return DBOS.#withTopContext({ operationCaller: callerName }, callback);
     }
+    /**
+     * @deprecated
+     * Use queue named `queueName` for any workflows started within the `callback`.
+     * @param queueName - Name of queue upon which all workflows called or started within `callback` will be run
+     * @param callback - Function to run, which would call or start workflows
+     * @returns - Return value from `callback`
+     */
+    static async withWorkflowQueue(queueName, callback) {
+        (0, decorators_1.ensureDBOSIsLaunched)('workflows');
+        return DBOS.#withTopContext({ queueAssignedForWorkflows: queueName }, callback);
+    }
     /**
      * Specify workflow timeout for any workflows started within the `callback`.
      * @param timeoutMS - timeout length for all workflows started within `callback` will be run
@@ -665,7 +902,7 @@ class DBOS {
     static startWorkflow(target, params) {
         (0, decorators_1.ensureDBOSIsLaunched)('workflows');
         const instance = typeof target === 'function' ? null : target;
-        if (instance && typeof instance !== 'function' && !(instance instanceof decorators_1.ConfiguredInstance)) {
+        if (instance && typeof instance !== 'function' && !(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);
@@ -931,7 +1168,7 @@ class DBOS {
         const queueName = params.queueName ?? ppctx?.queueAssignedForWorkflows;
         const timeoutMS = params.timeoutMS ?? ppctx?.workflowTimeoutMS;
         const instance = $this === undefined || typeof $this === 'function' ? undefined : $this;
-        if (instance && !(instance instanceof decorators_1.ConfiguredInstance)) {
+        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,
@@ -969,6 +1206,10 @@ class DBOS {
                 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);
@@ -995,6 +1236,95 @@ class DBOS {
         });
         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
+     * @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.wrapDBOSFunctionAndRegisterByUniqueNameDec)(target, propertyKey, inDescriptor);
+            registration.setTxnConfig(config);
+            const invokeWrapper = async function (...rawArgs) {
+                (0, decorators_1.ensureDBOSIsLaunched)('transactions');
+                let inst = undefined;
+                if (this === undefined || typeof this === 'function') {
+                    // This is static
+                }
+                else {
+                    inst = this;
+                    if (!(inst instanceof _2.ConfiguredInstance)) {
+                        throw new error_1.DBOSInvalidWorkflowTransitionError('Attempt to call a `transaction` function on an object that is not a `ConfiguredInstance`');
+                    }
+                }
+                if (DBOS.isWithinWorkflow()) {
+                    if (DBOS.isInTransaction()) {
+                        throw new error_1.DBOSInvalidWorkflowTransitionError('Invalid call to a `transaction` function from within a `transaction`');
+                    }
+                    if (DBOS.isInStep()) {
+                        throw new error_1.DBOSInvalidWorkflowTransitionError('Invalid call to a `transaction` function from within a `step`');
+                    }
+                    return await dbos_executor_1.DBOSExecutor.globalInstance.callTransactionFunction(registration.registeredFunction, inst ?? null, ...rawArgs);
+                }
+                const wfId = (0, context_1.getNextWFID)(undefined);
+                const wfParams = {
+                    configuredInstance: inst,
+                    workflowUUID: wfId,
+                };
+                return await DBOS.#executor.runTransactionTempWF(registration.registeredFunction, wfParams, ...rawArgs);
+            };
+            descriptor.value = invokeWrapper;
+            registration.wrappedFunction = invokeWrapper;
+            (0, decorators_1.registerFunctionWrapper)(invokeWrapper, registration);
+            Object.defineProperty(invokeWrapper, 'name', {
+                value: registration.name,
+            });
+            return descriptor;
+        }
+        return decorator;
+    }
+    /**
+     * Decorator designating a method as a DBOS stored procedure.
+     *   Within the procedure, `DBOS.sqlClient` is available for database operations.
+     *   A durable execution checkpoint will be applied to to the underlying database transaction
+     * @param config - Configuration information for the stored procedure, particularly its execution mode
+     */
+    static storedProcedure(config = {}) {
+        function decorator(target, propertyKey, inDescriptor) {
+            const { descriptor, registration } = (0, decorators_1.wrapDBOSFunctionAndRegisterByUniqueNameDec)(target, propertyKey, inDescriptor);
+            registration.setProcConfig(config);
+            const invokeWrapper = async function (...rawArgs) {
+                (0, decorators_1.ensureDBOSIsLaunched)('stored procedures');
+                if (typeof this !== 'function') {
+                    throw new Error('Stored procedures must be static');
+                }
+                if (DBOS.isWithinWorkflow()) {
+                    return await dbos_executor_1.DBOSExecutor.globalInstance.callProcedureFunction(registration.registeredFunction, ...rawArgs);
+                }
+                const wfId = (0, context_1.getNextWFID)(undefined);
+                const wfParams = {
+                    workflowUUID: wfId,
+                };
+                return await DBOS.#executor.runProcedureTempWF(registration.registeredFunction, wfParams, ...rawArgs);
+            };
+            descriptor.value = invokeWrapper;
+            registration.wrappedFunction = invokeWrapper;
+            (0, decorators_1.registerFunctionWrapper)(invokeWrapper, registration);
+            Object.defineProperty(invokeWrapper, 'name', {
+                value: registration.name,
+            });
+            return descriptor;
+        }
+        return decorator;
+    }
     /**
      * Decorator designating a method as a DBOS step.
      *   A durable checkpoint will be made after the step completes
@@ -1015,7 +1345,7 @@ class DBOS {
                 }
                 else {
                     inst = this;
-                    if (!(inst instanceof decorators_1.ConfiguredInstance)) {
+                    if (!(inst instanceof _2.ConfiguredInstance)) {
                         throw new error_1.DBOSInvalidWorkflowTransitionError('Attempt to call a `step` function on an object that is not a `ConfiguredInstance`');
                     }
                 }
@@ -1107,6 +1437,51 @@ class DBOS {
         }
         return func();
     }
+    /**
+     * Register serialization recipe; this is used to save/retrieve objects from the DBOS system
+     *  database.  This includes workflow inputs, function return values, messages, and events.
+     */
+    static registerSerialization(serReg) {
+        if (DBOS.isInitialized()) {
+            throw new TypeError(`Serializers/deserializers should not be registered after DBOS.launch()`);
+        }
+        (0, utils_1.registerSerializationRecipe)(serReg);
+    }
+    /**
+     * 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`
+     * @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`
+     * @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`
+     * @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`
+     * @deprecated - use `@dbos-inc/koa-serve`
+     */
+    static deleteApi(url) {
+        return httpApiDec(handlerTypes_1.APITypes.DELETE, url);
+    }
     /**
      * Decorate a class with the default list of required roles.
      *   This class-level default can be overridden on a per-function basis with `requiredRole`.
@@ -1163,10 +1538,31 @@ class DBOS {
     static associateFunctionWithInfo(external, func, target) {
         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.name, func, target.param);
+    }
     /** Get registrations */
     static getAssociatedInfo(external, cls, funcName) {
         return (0, decorators_1.getRegistrationsForExternal)(external, cls, funcName);
     }
 }
 exports.DBOS = DBOS;
+/** @deprecated */
+class InitContext {
+    createUserSchema() {
+        DBOS.logger.warn('Schema synchronization is deprecated and unsafe for production use. Please use migrations instead: https://typeorm.io/migrations');
+        return DBOS.createUserSchema();
+    }
+    dropUserSchema() {
+        DBOS.logger.warn('Schema synchronization is deprecated and unsafe for production use. Please use migrations instead: https://typeorm.io/migrations');
+        return DBOS.dropUserSchema();
+    }
+    queryUserDB(sql, ...params) {
+        return DBOS.queryUserDB(sql, params);
+    }
+}
+exports.InitContext = InitContext;
 //# sourceMappingURL=dbos.js.map