@dbos-inc/dbos-sdk 3.0.27-preview → 3.0.35-preview

package/dist/src/decorators.js

@@ -1,40 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DBOSInitializer = exports.OrmEntities = exports.configureInstance = exports.ArgName = exports.getRegistrationsForExternal = exports.associateParameterWithExternal = exports.associateMethodWithExternal = exports.associateMethodWithEventReceiver = exports.associateClassWithExternal = exports.associateClassWithEventReceiver = exports.getOrCreateClassRegistration = exports.getClassRegistrationByName = exports.getAllRegisteredClassNames = exports.getNameForClass = exports.registerAndWrapDBOSFunctionByName = exports.registerAndWrapDBOSFunction = exports.getOrCreateMethodArgsRegistration = exports.getTransactionalDataSource = exports.registerTransactionalDataSource = exports.transactionalDataSources = exports.getConfiguredInstance = exports.getRegisteredOperationsByClassname = exports.getRegisteredOperations = exports.getRegistrationForFunction = exports.registerFunctionWrapper = exports.getRegisteredMethodName = exports.getRegisteredMethodClassName = exports.ensureDBOSIsNotLaunched = exports.recordDBOSShutdown = exports.recordDBOSLaunch = exports.ClassRegistration = exports.ConfiguredInstance = exports.MethodRegistration = exports.DBOS_AUTH = exports.MethodParameter = exports.DBOSDataType = exports.insertAllMiddleware = exports.registerMiddlewareInstaller = exports.getLifecycleListeners = exports.registerLifecycleCallback = void 0;
+exports.DBOSInitializer = exports.OrmEntities = exports.ArgName = exports.getRegistrationsForExternal = exports.associateParameterWithExternal = exports.associateMethodWithExternal = exports.associateClassWithExternal = exports.getTransactionalDataSource = exports.registerTransactionalDataSource = exports.transactionalDataSources = exports.getConfiguredInstance = exports.getOrCreateClassRegistration = exports.getClassRegistrationByName = exports.getAllRegisteredFunctions = exports.getAllRegisteredClassNames = exports.getNameForClass = exports.wrapDBOSFunctionAndRegister = exports.wrapDBOSFunctionAndRegisterDec = exports.wrapDBOSFunctionAndRegisterByUniqueName = exports.wrapDBOSFunctionAndRegisterByUniqueNameDec = exports.getOrCreateMethodArgsRegistration = exports.getRegisteredFunctionsByClassname = exports.getRegisteredOperations = exports.getFunctionRegistrationByName = exports.getFunctionRegistration = exports.registerFunctionWrapper = exports.getRegisteredFunctionName = exports.getRegisteredFunctionClassName = exports.getRegisteredFunctionQualifiedName = exports.getRegisteredFunctionFullName = exports.insertAllMiddleware = exports.registerMiddlewareInstaller = exports.getLifecycleListeners = exports.registerLifecycleCallback = exports.ensureDBOSIsNotLaunched = exports.recordDBOSShutdown = exports.recordDBOSLaunch = exports.ClassRegistration = exports.ConfiguredInstance = exports.MethodRegistration = exports.DBOS_AUTH = exports.MethodParameter = exports.DBOSDataType = void 0;
 require("reflect-metadata");
 const error_1 = require("./error");
-const lifecycleListeners = [];
-function registerLifecycleCallback(lcl) {
-    if (!lifecycleListeners.includes(lcl))
-        lifecycleListeners.push(lcl);
-}
-exports.registerLifecycleCallback = registerLifecycleCallback;
-function getLifecycleListeners() {
-    return lifecycleListeners;
-}
-exports.getLifecycleListeners = getLifecycleListeners;
-let installedMiddleware = false;
-const middlewareInstallers = [];
-function registerMiddlewareInstaller(i) {
-    if (installedMiddleware)
-        throw new TypeError('Attempt to provide method middleware after insertion was performed');
-    if (!middlewareInstallers.includes(i))
-        middlewareInstallers.push(i);
-}
-exports.registerMiddlewareInstaller = registerMiddlewareInstaller;
-function insertAllMiddleware() {
-    if (installedMiddleware)
-        return;
-    installedMiddleware = true;
-    for (const [_cn, c] of classesByName) {
-        for (const [_fn, f] of c.reg.registeredOperations) {
-            for (const i of middlewareInstallers) {
-                i.installMiddleware(f);
-            }
-        }
-    }
-}
-exports.insertAllMiddleware = insertAllMiddleware;
 class DBOSDataType {
     dataType = 'text';
     length = -1;
@@ -222,9 +190,6 @@ class MethodParameter {
     }
 }
 exports.MethodParameter = MethodParameter;
-//////////////////////////////////////////
-/* REGISTRATION OBJECTS and read access */
-//////////////////////////////////////////
 exports.DBOS_AUTH = 'auth';
 class MethodRegistration {
     defaults;
@@ -251,7 +216,6 @@ class MethodRegistration {
     stepConfig;
     procConfig;
     regLocation;
-    eventReceiverInfo = new Map();
     externalRegInfo = new Map();
     getRegisteredInfo(reg) {
         if (!this.externalRegInfo.has(reg)) {
@@ -320,14 +284,6 @@ class MethodRegistration {
     }
 }
 exports.MethodRegistration = MethodRegistration;
-function registerClassInstance(inst, name) {
-    const creg = getOrCreateClassRegistration(inst.constructor);
-    if (creg.configuredInstances.has(name)) {
-        throw new error_1.DBOSConflictingRegistrationError(`An instance of class '${inst.constructor.name}' with name '${name}' was already registered.  Earlier registration occurred at:\n${(creg.configuredInstanceRegLocs.get(name) ?? []).join('\n')}`);
-    }
-    creg.configuredInstances.set(name, inst);
-    creg.configuredInstanceRegLocs.set(name, new StackGrabber().getCleanStack(3) ?? []);
-}
 class ConfiguredInstance {
     name;
     constructor(name) {
@@ -351,11 +307,23 @@ class ClassRegistration {
     needsInitialized = true;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     ormEntities = [];
-    registeredOperations = new Map();
+    registeredOperationsByName = new Map();
+    allRegisteredOperations = new Map();
     configuredInstances = new Map();
     configuredInstanceRegLocs = new Map();
-    eventReceiverInfo = new Map();
     externalRegInfo = new Map();
+    registerOperationByName(name, reg) {
+        const er = this.registeredOperationsByName.get(name);
+        if (er && er !== reg) {
+            let error = `Operation (Name: ${this.name}.${name}) is already registered.`;
+            if (er.regLocation) {
+                error = error + `\nPrior registration occurred at:\n${er.regLocation.join('\n')}`;
+            }
+            throw new error_1.DBOSConflictingRegistrationError(`${error}`);
+        }
+        this.registeredOperationsByName.set(name, reg);
+        reg.regLocation = new StackGrabber().getCleanStack(3);
+    }
     getRegisteredInfo(reg) {
         if (!this.externalRegInfo.has(reg)) {
             this.externalRegInfo.set(reg, {});
@@ -365,6 +333,8 @@ class ClassRegistration {
     constructor() { }
 }
 exports.ClassRegistration = ClassRegistration;
+// #endregion
+// #region Global registration structures and functions
 class StackGrabber extends Error {
     constructor() {
         super('StackGrabber');
@@ -377,6 +347,7 @@ class StackGrabber extends Error {
             .map((l) => '>>> ' + l.replace(/^\s*at\s*/, '')); // Remove the first lines
     }
 }
+// Track if DBOS is launched, and if so, from where
 let dbosLaunchPoint = undefined;
 function recordDBOSLaunch() {
     dbosLaunchPoint = new StackGrabber().getCleanStack(2); // Remove one for record, one for registerAndWrap...
@@ -392,38 +363,100 @@ function ensureDBOSIsNotLaunched() {
     }
 }
 exports.ensureDBOSIsNotLaunched = ensureDBOSIsNotLaunched;
-// This is a bit ugly, if we got the class / instance it would help avoid this auxiliary structure
-const methodToRegistration = new Map();
-function getRegisteredMethodClassName(func) {
-    let rv = '';
-    if (methodToRegistration.has(func)) {
-        rv = methodToRegistration.get(func).className;
+// DBOS launch lifecycle listener
+const lifecycleListeners = [];
+function registerLifecycleCallback(lcl) {
+    if (!lifecycleListeners.includes(lcl))
+        lifecycleListeners.push(lcl);
+}
+exports.registerLifecycleCallback = registerLifecycleCallback;
+function getLifecycleListeners() {
+    return lifecycleListeners;
+}
+exports.getLifecycleListeners = getLifecycleListeners;
+// Middleware installers - insert middleware in registered functions prior to launch
+let installedMiddleware = false;
+const middlewareInstallers = [];
+function registerMiddlewareInstaller(i) {
+    if (installedMiddleware)
+        throw new TypeError('Attempt to provide method middleware after insertion was performed');
+    if (!middlewareInstallers.includes(i))
+        middlewareInstallers.push(i);
+}
+exports.registerMiddlewareInstaller = registerMiddlewareInstaller;
+function insertAllMiddleware() {
+    if (installedMiddleware)
+        return;
+    installedMiddleware = true;
+    for (const [_cn, c] of classesByName) {
+        for (const f of c.reg.allRegisteredOperations.values()) {
+            for (const i of middlewareInstallers) {
+                i.installMiddleware(f);
+            }
+        }
+    }
+}
+exports.insertAllMiddleware = insertAllMiddleware;
+// Registration of functions, and classes
+const functionToRegistration = new Map();
+// Registration of instance, by constructor+name
+function registerClassInstance(inst, instname) {
+    const creg = getOrCreateClassRegistration(inst.constructor);
+    if (creg.configuredInstances.has(instname)) {
+        throw new error_1.DBOSConflictingRegistrationError(`An instance of class '${inst.constructor.name}' with name '${instname}' was already registered.  Earlier registration occurred at:\n${(creg.configuredInstanceRegLocs.get(instname) ?? []).join('\n')}`);
     }
-    return rv;
+    creg.configuredInstances.set(instname, inst);
+    creg.configuredInstanceRegLocs.set(instname, new StackGrabber().getCleanStack(3) ?? []);
 }
-exports.getRegisteredMethodClassName = getRegisteredMethodClassName;
-function getRegisteredMethodName(func) {
-    let rv = '';
-    if (methodToRegistration.has(func)) {
-        rv = methodToRegistration.get(func).name;
+function getRegisteredFunctionFullName(func) {
+    let className = '';
+    let funcName = func.name ?? '';
+    if (functionToRegistration.has(func)) {
+        const fr = functionToRegistration.get(func);
+        className = fr.className;
+        funcName = fr.name;
     }
-    return rv;
+    return { className, name: funcName };
+}
+exports.getRegisteredFunctionFullName = getRegisteredFunctionFullName;
+function getRegisteredFunctionQualifiedName(func) {
+    const fn = getRegisteredFunctionFullName(func);
+    return fn.className + '.' + fn.name;
 }
-exports.getRegisteredMethodName = getRegisteredMethodName;
+exports.getRegisteredFunctionQualifiedName = getRegisteredFunctionQualifiedName;
+function getRegisteredFunctionClassName(func) {
+    return getRegisteredFunctionFullName(func).className;
+}
+exports.getRegisteredFunctionClassName = getRegisteredFunctionClassName;
+function getRegisteredFunctionName(func) {
+    return getRegisteredFunctionFullName(func).name;
+}
+exports.getRegisteredFunctionName = getRegisteredFunctionName;
 function registerFunctionWrapper(func, reg) {
-    methodToRegistration.set(func, reg);
+    reg.wrappedFunction = func;
+    functionToRegistration.set(func, reg);
 }
 exports.registerFunctionWrapper = registerFunctionWrapper;
-function getRegistrationForFunction(func) {
-    return methodToRegistration.get(func);
+function getFunctionRegistration(func) {
+    return functionToRegistration.get(func);
+}
+exports.getFunctionRegistration = getFunctionRegistration;
+function getFunctionRegistrationByName(className, name) {
+    const clsreg = getClassRegistrationByName(className, false);
+    if (!clsreg)
+        return undefined;
+    const methReg = clsreg.registeredOperationsByName.get(name);
+    if (!methReg)
+        return undefined;
+    return methReg;
 }
-exports.getRegistrationForFunction = getRegistrationForFunction;
+exports.getFunctionRegistrationByName = getFunctionRegistrationByName;
 function getRegisteredOperations(target) {
     const registeredOperations = [];
     if (typeof target === 'function') {
         // Constructor case
         const classReg = classesByName.get(target.name);
-        classReg?.reg?.registeredOperations?.forEach((m) => registeredOperations.push(m));
+        classReg?.reg?.allRegisteredOperations?.forEach((m) => registeredOperations.push(m));
     }
     else {
         let current = target;
@@ -438,70 +471,35 @@ function getRegisteredOperations(target) {
     return registeredOperations;
 }
 exports.getRegisteredOperations = getRegisteredOperations;
-function getRegisteredOperationsByClassname(target) {
+function getRegisteredFunctionsByClassname(target) {
     const registeredOperations = [];
     const cls = getClassRegistrationByName(target);
-    cls.registeredOperations?.forEach((m) => registeredOperations.push(m));
+    cls?.allRegisteredOperations?.forEach((m) => registeredOperations.push(m));
     return registeredOperations;
 }
-exports.getRegisteredOperationsByClassname = getRegisteredOperationsByClassname;
-function getConfiguredInstance(clsname, cfgname) {
-    const classReg = classesByName.get(clsname)?.reg;
-    if (!classReg)
-        return null;
-    return classReg.configuredInstances.get(cfgname) ?? null;
-}
-exports.getConfiguredInstance = getConfiguredInstance;
-/////
-// Transactional data source registration
-/////
-exports.transactionalDataSources = new Map();
-// Register data source (user version)
-function registerTransactionalDataSource(name, ds) {
-    if (exports.transactionalDataSources.has(name)) {
-        if (exports.transactionalDataSources.get(name) !== ds) {
-            throw new error_1.DBOSConflictingRegistrationError(`Data source with name ${name} is already registered`);
-        }
-        return;
-    }
-    ensureDBOSIsNotLaunched();
-    exports.transactionalDataSources.set(name, ds);
-}
-exports.registerTransactionalDataSource = registerTransactionalDataSource;
-function getTransactionalDataSource(name) {
-    if (exports.transactionalDataSources.has(name))
-        return exports.transactionalDataSources.get(name);
-    throw new error_1.DBOSNotRegisteredError(name, `Data source '${name}' is not registered`);
-}
-exports.getTransactionalDataSource = getTransactionalDataSource;
-////////////////////////////////////////////////////////////////////////////////
-// DECORATOR REGISTRATION
-// These manage registration objects, creating them at decorator evaluation time
-// and making wrapped methods available for function registration at runtime
-// initialization time.
-////////////////////////////////////////////////////////////////////////////////
+exports.getRegisteredFunctionsByClassname = getRegisteredFunctionsByClassname;
 const methodArgsByFunction = new Map();
-function getOrCreateMethodArgsRegistration(target, className, funcName, func) {
+function getOrCreateMethodArgsRegistration(target, funcName, origFunc) {
     let regtarget = target;
     if (regtarget && typeof regtarget !== 'function') {
         regtarget = regtarget.constructor;
     }
-    className = className ?? (target ? getNameForClass(target) : '');
-    const mkey = className + '|' + funcName.toString();
-    let mParameters = methodArgsByFunction.get(mkey);
+    if (!origFunc) {
+        origFunc = Object.getOwnPropertyDescriptor(target, funcName).value;
+    }
+    let mParameters = methodArgsByFunction.get(origFunc);
     if (mParameters === undefined) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
         let designParamTypes = undefined;
         if (target) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
             designParamTypes = Reflect.getMetadata('design:paramtypes', target, funcName);
         }
         if (designParamTypes) {
             mParameters = designParamTypes.map((value, index) => new MethodParameter(index, value));
         }
         else {
-            if (func) {
-                const argnames = getArgNames(func);
+            if (origFunc) {
+                const argnames = getArgNames(origFunc);
                 mParameters = argnames.map((_value, index) => new MethodParameter(index));
             }
             else {
@@ -511,44 +509,28 @@ function getOrCreateMethodArgsRegistration(target, className, funcName, func) {
                 mParameters = argnames.map((_value, index) => new MethodParameter(index));
             }
         }
-        methodArgsByFunction.set(mkey, mParameters);
+        methodArgsByFunction.set(origFunc, mParameters);
     }
     return mParameters;
 }
 exports.getOrCreateMethodArgsRegistration = getOrCreateMethodArgsRegistration;
 function getOrCreateMethodRegistration(target, className, propertyKey, func) {
-    let regtarget = undefined;
-    let isInstance = false;
-    if (target) {
-        if (typeof target === 'function') {
-            // Static method case
-            regtarget = target;
-        }
-        else {
-            // Instance method case
-            regtarget = target.constructor;
-            isInstance = true;
-        }
-    }
-    if (!className) {
-        if (regtarget)
-            className = regtarget.name;
-    }
-    if (!className) {
-        className = '';
-    }
-    const classReg = getClassRegistrationByName(className, true);
+    let classReg;
+    let isInstance;
+    ({ classReg, isInstance, className } = getOrCreateClassRegistrationByName(target, className));
     const fname = propertyKey.toString();
-    if (!classReg.registeredOperations.has(fname)) {
-        classReg.registeredOperations.set(fname, new MethodRegistration(func, isInstance));
+    const origFunc = functionToRegistration.get(func)?.origFunction ?? func;
+    if (!classReg.allRegisteredOperations.has(origFunc)) {
+        const reg = new MethodRegistration(func, isInstance);
+        classReg.allRegisteredOperations.set(func, reg);
     }
-    const methReg = classReg.registeredOperations.get(fname);
+    const methReg = classReg.allRegisteredOperations.get(func);
     if (methReg.needInitialized) {
         methReg.needInitialized = false;
         methReg.name = fname;
         methReg.className = classReg.name;
         methReg.defaults = classReg;
-        methReg.args = getOrCreateMethodArgsRegistration(target, className, propertyKey, func);
+        methReg.args = getOrCreateMethodArgsRegistration(target, propertyKey, func);
         const argNames = getArgNames(func);
         methReg.args.forEach((e) => {
             if (!e.name) {
@@ -568,27 +550,54 @@ function getOrCreateMethodRegistration(target, className, propertyKey, func) {
             value: methReg.name,
         });
         methReg.registeredFunction = wrappedMethod;
-        methodToRegistration.set(methReg.registeredFunction, methReg);
-        methodToRegistration.set(methReg.origFunction, methReg);
+        functionToRegistration.set(methReg.registeredFunction, methReg);
+        functionToRegistration.set(methReg.origFunction, methReg);
     }
     return methReg;
 }
-function registerAndWrapDBOSFunction(target, propertyKey, descriptor) {
+function wrapDBOSFunctionAndRegisterByUniqueNameDec(target, propertyKey, descriptor) {
+    if (!descriptor.value) {
+        throw Error('Use of decorator when original method is undefined');
+    }
+    const registration = wrapDBOSFunctionAndRegisterByUniqueName(target, undefined, propertyKey, descriptor.value);
+    descriptor.value = registration.wrappedFunction ?? registration.registeredFunction;
+    return { descriptor, registration };
+}
+exports.wrapDBOSFunctionAndRegisterByUniqueNameDec = wrapDBOSFunctionAndRegisterByUniqueNameDec;
+function wrapDBOSFunctionAndRegisterByUniqueName(ctorOrProto, className, propertyKey, func) {
     ensureDBOSIsNotLaunched();
+    const name = typeof propertyKey === 'string' ? propertyKey : propertyKey.toString();
+    const freg = getFunctionRegistration(func);
+    if (freg) {
+        const r = getOrCreateClassRegistrationByName(ctorOrProto, className);
+        r.classReg.registerOperationByName(name, freg);
+        return freg;
+    }
+    const registration = getOrCreateMethodRegistration(ctorOrProto, className, propertyKey, func);
+    const r = getOrCreateClassRegistrationByName(ctorOrProto, className);
+    r.classReg.registerOperationByName(name, registration);
+    return registration;
+}
+exports.wrapDBOSFunctionAndRegisterByUniqueName = wrapDBOSFunctionAndRegisterByUniqueName;
+function wrapDBOSFunctionAndRegisterDec(target, propertyKey, descriptor) {
     if (!descriptor.value) {
         throw Error('Use of decorator when original method is undefined');
     }
-    const registration = getOrCreateMethodRegistration(target, undefined, propertyKey, descriptor.value);
+    const registration = wrapDBOSFunctionAndRegister(target, undefined, propertyKey, descriptor.value);
     descriptor.value = registration.wrappedFunction ?? registration.registeredFunction;
     return { descriptor, registration };
 }
-exports.registerAndWrapDBOSFunction = registerAndWrapDBOSFunction;
-function registerAndWrapDBOSFunctionByName(target, className, funcName, func) {
+exports.wrapDBOSFunctionAndRegisterDec = wrapDBOSFunctionAndRegisterDec;
+function wrapDBOSFunctionAndRegister(ctorOrProto, className, propertyKey, func) {
     ensureDBOSIsNotLaunched();
-    const registration = getOrCreateMethodRegistration(target, className, funcName, func);
-    return { registration };
+    const freg = getFunctionRegistration(func);
+    if (freg) {
+        return freg;
+    }
+    const registration = getOrCreateMethodRegistration(ctorOrProto, className, propertyKey, func);
+    return registration;
 }
-exports.registerAndWrapDBOSFunctionByName = registerAndWrapDBOSFunctionByName;
+exports.wrapDBOSFunctionAndRegister = wrapDBOSFunctionAndRegister;
 const classesByName = new Map();
 const classesByCtor = new Map();
 function getNameForClass(ctor) {
@@ -614,6 +623,18 @@ function getAllRegisteredClassNames() {
     return cnames;
 }
 exports.getAllRegisteredClassNames = getAllRegisteredClassNames;
+function getAllRegisteredFunctions() {
+    const s = new Set();
+    const fregs = [];
+    for (const [_f, reg] of functionToRegistration) {
+        if (s.has(reg))
+            continue;
+        fregs.push(reg);
+        s.add(reg);
+    }
+    return fregs;
+}
+exports.getAllRegisteredFunctions = getAllRegisteredFunctions;
 function getClassRegistrationByName(name, create = false) {
     if (!classesByName.has(name) && !create) {
         throw new error_1.DBOSNotRegisteredError(name, `Class '${name}' is not registered`);
@@ -642,54 +663,72 @@ function getOrCreateClassRegistration(ctor) {
     return clsReg;
 }
 exports.getOrCreateClassRegistration = getOrCreateClassRegistration;
-/**
- * Associates a class with a `DBOSEventReceiver`, which will be calling the class's DBOS methods.
- * Allows class-level default values or other storage to be associated with the class, rather than
- *   separately for each registered method.
- *
- * @param rcvr - Event receiver which will dispatch DBOS methods from the class specified by `ctor`
- * @param ctor - Constructor of the class that is being registered and associated with `rcvr`
- * @returns - Class-specific registration info cumulatively collected for `rcvr`
- */
-function associateClassWithEventReceiver(rcvr, ctor) {
-    const clsReg = getOrCreateClassRegistration(ctor);
-    if (!clsReg.eventReceiverInfo.has(rcvr)) {
-        clsReg.eventReceiverInfo.set(rcvr, {});
+function getOrCreateClassRegistrationByName(target, className) {
+    let regtarget = undefined;
+    let isInstance = false;
+    if (target) {
+        if (typeof target === 'function') {
+            // Static method case
+            regtarget = target;
+        }
+        else {
+            // Instance method case
+            regtarget = target.constructor;
+            isInstance = true;
+        }
+    }
+    if (!className) {
+        if (regtarget)
+            className = regtarget.name;
     }
-    return clsReg.eventReceiverInfo.get(rcvr);
+    if (!className) {
+        className = '';
+    }
+    const classReg = getClassRegistrationByName(className, true);
+    return { classReg, isInstance, className };
+}
+function getConfiguredInstance(clsname, cfgname) {
+    const classReg = classesByName.get(clsname)?.reg;
+    if (!classReg)
+        return null;
+    return classReg.configuredInstances.get(cfgname) ?? null;
 }
-exports.associateClassWithEventReceiver = associateClassWithEventReceiver;
+exports.getConfiguredInstance = getConfiguredInstance;
+// #endregion
+// #region Transactional data source registration
+exports.transactionalDataSources = new Map();
+// Register data source (user version)
+function registerTransactionalDataSource(name, ds) {
+    if (exports.transactionalDataSources.has(name)) {
+        if (exports.transactionalDataSources.get(name) !== ds) {
+            throw new error_1.DBOSConflictingRegistrationError(`Data source with name ${name} is already registered`);
+        }
+        return;
+    }
+    ensureDBOSIsNotLaunched();
+    exports.transactionalDataSources.set(name, ds);
+}
+exports.registerTransactionalDataSource = registerTransactionalDataSource;
+function getTransactionalDataSource(name) {
+    if (exports.transactionalDataSources.has(name))
+        return exports.transactionalDataSources.get(name);
+    throw new error_1.DBOSNotRegisteredError(name, `Data source '${name}' is not registered`);
+}
+exports.getTransactionalDataSource = getTransactionalDataSource;
+// #endregion
+// #region External (event receiver v3)
 function associateClassWithExternal(external, cls) {
     const clsn = typeof cls === 'string' ? cls : getNameForClass(cls);
     const clsreg = getClassRegistrationByName(clsn, true);
     return clsreg.getRegisteredInfo(external);
 }
 exports.associateClassWithExternal = associateClassWithExternal;
-/**
- * Associates a workflow method with a `DBOSEventReceiver` which will be in charge of calling the method
- *   in response to received events.
- * This version is to be used in "Stage 2" decorators, as it applies the DBOS wrapper to the registered method.
- *
- * @param rcvr - `DBOSEventReceiver` instance that should be informed of the `target` method's registration
- * @param target - A DBOS method to associate with the event receiver
- * @param propertyKey - For Stage 2 decorator use, this is the property key used for replacing the method with its wrapper
- * @param inDescriptor - For Stage 2 decorator use, this is the method descriptor used for replacing the method with its wrapper
- * @returns The new method descriptor, registration, and event receiver info
- */
-function associateMethodWithEventReceiver(rcvr, target, propertyKey, inDescriptor) {
-    const { descriptor, registration } = registerAndWrapDBOSFunction(target, propertyKey, inDescriptor);
-    if (!registration.eventReceiverInfo.has(rcvr)) {
-        registration.eventReceiverInfo.set(rcvr, {});
-    }
-    return { descriptor, registration, receiverInfo: registration.eventReceiverInfo.get(rcvr) };
-}
-exports.associateMethodWithEventReceiver = associateMethodWithEventReceiver;
 /*
  * Associates a DBOS function or method with an external class or object.
  *   Likely, this will be invoking or intercepting the method.
  */
 function associateMethodWithExternal(external, target, className, funcName, func) {
-    const { registration } = registerAndWrapDBOSFunctionByName(target, className, funcName, func);
+    const registration = wrapDBOSFunctionAndRegister(target, className, funcName, func);
     if (!registration.externalRegInfo.has(external)) {
         registration.externalRegInfo.set(external, {});
     }
@@ -697,14 +736,14 @@ function associateMethodWithExternal(external, target, className, funcName, func
 }
 exports.associateMethodWithExternal = associateMethodWithExternal;
 /*
- * Associates a DBOS function or method with an external class or object.
+ * Associates a DBOS function or method parameters with an external class or object.
  *   Likely, this will be invoking or intercepting the method.
  */
 function associateParameterWithExternal(external, target, className, funcName, func, paramId) {
     if (!func) {
         func = Object.getOwnPropertyDescriptor(target, funcName).value;
     }
-    const { registration } = registerAndWrapDBOSFunctionByName(target, className, funcName, func);
+    const registration = wrapDBOSFunctionAndRegister(target, className, funcName, func);
     let param;
     if (typeof paramId === 'number') {
         param = registration.args[paramId];
@@ -721,13 +760,13 @@ function associateParameterWithExternal(external, target, className, funcName, f
 }
 exports.associateParameterWithExternal = associateParameterWithExternal;
 function getRegistrationsForExternal(external, cls, funcName) {
-    const res = [];
+    const res = new Array();
     if (cls) {
         const clsname = typeof cls === 'string' ? cls : getNameForClass(cls);
         const c = classesByName.get(clsname);
         if (c) {
             if (funcName) {
-                const f = c.reg.registeredOperations.get(funcName);
+                const f = c.reg.registeredOperationsByName.get(funcName);
                 if (f) {
                     collectRegForFunction(f);
                 }
@@ -744,7 +783,7 @@ function getRegistrationsForExternal(external, cls, funcName) {
     }
     return res;
     function collectRegForClass(c) {
-        for (const [_fn, f] of c.reg.registeredOperations) {
+        for (const f of c.reg.allRegisteredOperations.values()) {
             collectRegForFunction(f);
         }
     }
@@ -768,26 +807,18 @@ function getRegistrationsForExternal(external, cls, funcName) {
     }
 }
 exports.getRegistrationsForExternal = getRegistrationsForExternal;
-//////////////////////////
-/* PARAMETER DECORATORS */
-//////////////////////////
+// #endregion
+// #region Parameter decorators
 function ArgName(name) {
     return function (target, propertyKey, parameterIndex) {
-        const existingParameters = getOrCreateMethodArgsRegistration(target, undefined, propertyKey);
+        const existingParameters = getOrCreateMethodArgsRegistration(target, propertyKey);
         const curParam = existingParameters[parameterIndex];
         curParam.name = name;
     };
 }
 exports.ArgName = ArgName;
-///////////////////////
-/* CLASS DECORATORS */
-///////////////////////
-/** @deprecated Use `new` */
-function configureInstance(cls, name, ...args) {
-    const inst = new cls(name, ...args);
-    return inst;
-}
-exports.configureInstance = configureInstance;
+// #endregion
+// #region Class decorators
 /**
  * @deprecated Use ORM DSs
  */
@@ -800,13 +831,16 @@ function OrmEntities(entities = []) {
     return clsdec;
 }
 exports.OrmEntities = OrmEntities;
+// #endregion
+// #region Method decorators
 function DBOSInitializer() {
     function decorator(target, propertyKey, inDescriptor) {
-        const { descriptor, registration } = registerAndWrapDBOSFunction(target, propertyKey, inDescriptor);
+        const { descriptor, registration } = wrapDBOSFunctionAndRegisterByUniqueNameDec(target, propertyKey, inDescriptor);
         registration.init = true;
         return descriptor;
     }
     return decorator;
 }
 exports.DBOSInitializer = DBOSInitializer;
+// #endregion
 //# sourceMappingURL=decorators.js.map