@dbos-inc/dbos-sdk 2.10.22 → 2.11.4-preview

package/dist/src/decorators.js

@@ -1,34 +1,56 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DBOSDeploy = exports.DBOSInitializer = exports.OrmEntities = exports.Step = exports.StoredProcedure = exports.Transaction = exports.Workflow = exports.RequiredRole = exports.configureInstance = exports.DefaultArgOptional = exports.DefaultArgValidate = exports.DefaultArgRequired = exports.DefaultRequiredRole = exports.ArgVarchar = exports.ArgDate = exports.ArgName = exports.LogMask = exports.SkipLogging = exports.ArgOptional = exports.ArgRequired = exports.associateMethodWithEventReceiver = exports.associateClassWithEventReceiver = exports.getOrCreateClassRegistration = exports.getAllRegisteredClasses = exports.registerAndWrapDBOSFunction = exports.registerAndWrapFunctionTakingContext = exports.getOrCreateMethodArgsRegistration = exports.getConfiguredInstance = exports.getRegisteredOperations = exports.registerFunctionWrapper = exports.getRegisteredMethodName = exports.getRegisteredMethodClassName = exports.ensureDBOSIsNotLaunched = exports.recordDBOSShutdown = exports.recordDBOSLaunch = exports.ClassRegistration = exports.ConfiguredInstance = exports.MethodRegistration = exports.MethodParameter = exports.ArgRequiredOptions = exports.LogMasks = exports.DBOSDataType = void 0;
+exports.DBOSDeploy = exports.DBOSInitializer = exports.OrmEntities = exports.Step = exports.StoredProcedure = exports.Transaction = exports.Workflow = 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.registerAndWrapFunctionTakingContext = exports.getOrCreateMethodArgsRegistration = 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.registerMiddlewareInserter = exports.getLifecycleListeners = exports.registerLifecycleCallback = exports.DBOSLifecycleCallback = void 0;
 require("reflect-metadata");
-const crypto = __importStar(require("crypto"));
-const context_1 = require("./context");
 const error_1 = require("./error");
-const data_validation_1 = require("./data_validation");
+/**
+ * Interface for integrating into the DBOS startup/shutdown lifecycle
+ */
+class DBOSLifecycleCallback {
+    /** Called back during DBOS launch */
+    initialize() {
+        return Promise.resolve();
+    }
+    /** Called back upon shutdown (usually in tests) to close connections and free resources */
+    destroy() {
+        return Promise.resolve();
+    }
+    /** Called at launch; Implementers should emit a diagnostic list of all registrations */
+    logRegisteredEndpoints() { }
+}
+exports.DBOSLifecycleCallback = DBOSLifecycleCallback;
+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 middlewareInserters = [];
+function registerMiddlewareInserter(i) {
+    if (installedMiddleware)
+        throw new TypeError('Attempt to provide method middleware after insertion was performed');
+    if (!middlewareInserters.includes(i))
+        middlewareInserters.push(i);
+}
+exports.registerMiddlewareInserter = registerMiddlewareInserter;
+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 middlewareInserters) {
+                i.installMiddleware(f);
+            }
+        }
+    }
+}
+exports.insertAllMiddleware = insertAllMiddleware;
 class DBOSDataType {
     dataType = 'text';
     length = -1;
@@ -188,41 +210,48 @@ function getArgNames(func) {
     }
     return args;
 }
-var LogMasks;
-(function (LogMasks) {
-    LogMasks["NONE"] = "NONE";
-    LogMasks["HASH"] = "HASH";
-    LogMasks["SKIP"] = "SKIP";
-})(LogMasks || (exports.LogMasks = LogMasks = {}));
-var ArgRequiredOptions;
-(function (ArgRequiredOptions) {
-    ArgRequiredOptions["REQUIRED"] = "REQUIRED";
-    ArgRequiredOptions["OPTIONAL"] = "OPTIONAL";
-    ArgRequiredOptions["DEFAULT"] = "DEFAULT";
-})(ArgRequiredOptions || (exports.ArgRequiredOptions = ArgRequiredOptions = {}));
 class MethodParameter {
     name = '';
-    required = ArgRequiredOptions.DEFAULT;
-    validate = true;
-    logMask = LogMasks.NONE;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-    argType = undefined; // This comes from reflect-metadata, if we have it
-    dataType;
     index = -1;
+    externalRegInfo = new Map();
+    getRegisteredInfo(reg) {
+        if (!this.externalRegInfo.has(reg)) {
+            this.externalRegInfo.set(reg, {});
+        }
+        return this.externalRegInfo.get(reg);
+    }
+    get dataType() {
+        return this.getRegisteredInfo('type').dataType;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    initializeBaseType(at) {
+        if (!this.externalRegInfo.has('type')) {
+            this.externalRegInfo.set('type', {});
+        }
+        const adt = this.externalRegInfo.get('type');
+        adt.dataType = DBOSDataType.fromArg(at);
+    }
     // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     constructor(idx, at) {
         this.index = idx;
-        this.argType = at;
-        this.dataType = DBOSDataType.fromArg(at);
+        this.initializeBaseType(at);
     }
 }
 exports.MethodParameter = MethodParameter;
+//////////////////////////////////////////
+/* REGISTRATION OBJECTS and read access */
+//////////////////////////////////////////
+exports.DBOS_AUTH = 'auth';
 class MethodRegistration {
     defaults;
     name = '';
     className = '';
-    requiredRole = undefined;
-    performArgValidation = false;
+    // Interceptors
+    onEnter = [];
+    addEntryInterceptor(func, seqNum = 10) {
+        this.onEnter.push({ seqNum, func });
+        this.onEnter.sort((a, b) => a.seqNum - b.seqNum);
+    }
     args = [];
     passContext = false;
     constructor(origFunc, isInstance, passContext) {
@@ -241,6 +270,13 @@ class MethodRegistration {
     procConfig;
     regLocation;
     eventReceiverInfo = new Map();
+    externalRegInfo = new Map();
+    getRegisteredInfo(reg) {
+        if (!this.externalRegInfo.has(reg)) {
+            this.externalRegInfo.set(reg, {});
+        }
+        return this.externalRegInfo.get(reg);
+    }
     getAssignedType() {
         if (this.txnConfig)
             return 'Transaction';
@@ -289,13 +325,16 @@ class MethodRegistration {
     }
     init = false;
     invoke(pthis, args) {
-        return this.registeredFunction.call(pthis, ...args);
+        const f = this.wrappedFunction ?? this.registeredFunction ?? this.origFunction;
+        return f.call(pthis, ...args);
     }
     getRequiredRoles() {
-        if (this.requiredRole) {
-            return this.requiredRole;
+        const rr = this.getRegisteredInfo(exports.DBOS_AUTH);
+        if (rr?.requiredRole) {
+            return rr.requiredRole;
         }
-        return this.defaults?.requiredRole || [];
+        const drr = this.defaults?.getRegisteredInfo(exports.DBOS_AUTH);
+        return drr?.requiredRole || [];
     }
 }
 exports.MethodRegistration = MethodRegistration;
@@ -327,10 +366,6 @@ class ConfiguredInstance {
 exports.ConfiguredInstance = ConfiguredInstance;
 class ClassRegistration {
     name = '';
-    requiredRole;
-    argRequiredEnabled = false;
-    defaultArgRequired = ArgRequiredOptions.REQUIRED;
-    defaultArgValidate = false;
     needsInitialized = true;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     ormEntities = [];
@@ -338,10 +373,14 @@ class ClassRegistration {
     configuredInstances = new Map();
     configuredInstanceRegLocs = new Map();
     eventReceiverInfo = new Map();
-    ctor;
-    constructor(ctor) {
-        this.ctor = ctor;
+    externalRegInfo = new Map();
+    getRegisteredInfo(reg) {
+        if (!this.externalRegInfo.has(reg)) {
+            this.externalRegInfo.set(reg, {});
+        }
+        return this.externalRegInfo.get(reg);
     }
+    constructor() { }
 }
 exports.ClassRegistration = ClassRegistration;
 class StackGrabber extends Error {
@@ -393,12 +432,16 @@ function registerFunctionWrapper(func, reg) {
     methodToRegistration.set(func, reg);
 }
 exports.registerFunctionWrapper = registerFunctionWrapper;
+function getRegistrationForFunction(func) {
+    return methodToRegistration.get(func);
+}
+exports.getRegistrationForFunction = getRegistrationForFunction;
 function getRegisteredOperations(target) {
     const registeredOperations = [];
     if (typeof target === 'function') {
         // Constructor case
         const classReg = classesByName.get(target.name);
-        classReg?.registeredOperations?.forEach((m) => registeredOperations.push(m));
+        classReg?.reg?.registeredOperations?.forEach((m) => registeredOperations.push(m));
     }
     else {
         let current = target;
@@ -413,8 +456,15 @@ function getRegisteredOperations(target) {
     return registeredOperations;
 }
 exports.getRegisteredOperations = getRegisteredOperations;
+function getRegisteredOperationsByClassname(target) {
+    const registeredOperations = [];
+    const cls = getClassRegistrationByName(target);
+    cls.registeredOperations?.forEach((m) => registeredOperations.push(m));
+    return registeredOperations;
+}
+exports.getRegisteredOperationsByClassname = getRegisteredOperationsByClassname;
 function getConfiguredInstance(clsname, cfgname) {
-    const classReg = classesByName.get(clsname);
+    const classReg = classesByName.get(clsname)?.reg;
     if (!classReg)
         return null;
     return classReg.configuredInstances.get(cfgname) ?? null;
@@ -427,52 +477,66 @@ exports.getConfiguredInstance = getConfiguredInstance;
 // initialization time.
 ////////////////////////////////////////////////////////////////////////////////
 const methodArgsByFunction = new Map();
-function getOrCreateMethodArgsRegistration(target, propertyKey) {
+function getOrCreateMethodArgsRegistration(target, className, funcName, func) {
     let regtarget = target;
-    if (typeof regtarget !== 'function') {
+    if (regtarget && typeof regtarget !== 'function') {
         regtarget = regtarget.constructor;
     }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-    const mkey = regtarget.name + '|' + propertyKey.toString();
+    className = className ?? (target ? getNameForClass(target) : '');
+    const mkey = className + '|' + funcName.toString();
     let mParameters = methodArgsByFunction.get(mkey);
     if (mParameters === undefined) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-        const designParamTypes = Reflect.getMetadata('design:paramtypes', target, propertyKey);
+        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 {
-            const descriptor = Object.getOwnPropertyDescriptor(target, propertyKey);
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-            const argnames = getArgNames(descriptor?.value);
-            mParameters = argnames.map((_value, index) => new MethodParameter(index));
+            if (func) {
+                const argnames = getArgNames(func);
+                mParameters = argnames.map((_value, index) => new MethodParameter(index));
+            }
+            else {
+                const descriptor = Object.getOwnPropertyDescriptor(target, funcName);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+                const argnames = getArgNames(descriptor?.value);
+                mParameters = argnames.map((_value, index) => new MethodParameter(index));
+            }
         }
         methodArgsByFunction.set(mkey, mParameters);
     }
     return mParameters;
 }
 exports.getOrCreateMethodArgsRegistration = getOrCreateMethodArgsRegistration;
-function generateSaltedHash(data, salt) {
-    const hash = crypto.createHash('sha256'); // You can use other algorithms like 'md5', 'sha512', etc.
-    hash.update(data + salt);
-    return hash.digest('hex');
-}
-function getOrCreateMethodRegistration(target, propertyKey, descriptor, passContext) {
-    let regtarget;
+function getOrCreateMethodRegistration(target, className, propertyKey, func, passContext) {
+    let regtarget = undefined;
     let isInstance = false;
-    if (typeof target === 'function') {
-        // Static method case
-        regtarget = target;
+    if (target) {
+        if (typeof target === 'function') {
+            // Static method case
+            regtarget = target;
+        }
+        else {
+            // Instance method case
+            regtarget = target.constructor;
+            isInstance = true;
+        }
     }
-    else {
-        // Instance method case
-        regtarget = target.constructor;
-        isInstance = true;
+    if (!className) {
+        if (regtarget)
+            className = regtarget.name;
     }
-    const classReg = getOrCreateClassRegistration(regtarget);
+    if (!className) {
+        className = '';
+    }
+    const classReg = getClassRegistrationByName(className, true);
     const fname = propertyKey.toString();
     if (!classReg.registeredOperations.has(fname)) {
-        classReg.registeredOperations.set(fname, new MethodRegistration(descriptor.value, isInstance, passContext));
+        classReg.registeredOperations.set(fname, new MethodRegistration(func, isInstance, passContext));
     }
     const methReg = classReg.registeredOperations.get(fname);
     // Note: We cannot tell if the method takes a context or not.
@@ -486,86 +550,25 @@ function getOrCreateMethodRegistration(target, propertyKey, descriptor, passCont
         methReg.name = fname;
         methReg.className = classReg.name;
         methReg.defaults = classReg;
-        methReg.args = getOrCreateMethodArgsRegistration(target, propertyKey);
-        const argNames = getArgNames(descriptor.value);
+        methReg.args = getOrCreateMethodArgsRegistration(target, className, propertyKey, func);
+        const argNames = getArgNames(func);
         methReg.args.forEach((e) => {
-            if (e.required !== ArgRequiredOptions.DEFAULT) {
-                classReg.argRequiredEnabled = true;
-            }
             if (!e.name) {
                 if (e.index < argNames.length) {
                     e.name = argNames[e.index];
                 }
-                if (e.index === 0 && passContext) {
-                    // The first argument is always the context.
-                    e.logMask = LogMasks.SKIP;
-                }
-                // TODO else warn/log something
             }
         });
         const wrappedMethod = async function (...rawArgs) {
-            let opCtx = undefined;
-            if (passContext) {
-                opCtx = rawArgs[0];
-            }
-            else {
-                opCtx = (0, context_1.getCurrentDBOSContext)();
+            let validatedArgs = rawArgs;
+            for (const vf of methReg.onEnter) {
+                validatedArgs = vf.func(methReg, validatedArgs);
             }
-            // Validate the user authentication and populate the role field
-            const requiredRoles = methReg.getRequiredRoles();
-            if (requiredRoles.length > 0) {
-                opCtx.span.setAttribute('requiredRoles', requiredRoles);
-                const curRoles = opCtx.authenticatedRoles;
-                let authorized = false;
-                const set = new Set(curRoles);
-                for (const role of requiredRoles) {
-                    if (set.has(role)) {
-                        authorized = true;
-                        opCtx.assumedRole = role;
-                        break;
-                    }
-                }
-                if (!authorized) {
-                    const err = new error_1.DBOSNotAuthorizedError(`User does not have a role with permission to call ${methReg.name}`, 403);
-                    opCtx.span.addEvent('DBOSNotAuthorizedError', { message: err.message });
-                    throw err;
-                }
-            }
-            const validatedArgs = (0, data_validation_1.validateMethodArgs)(methReg, rawArgs);
-            // Argument logging
-            validatedArgs.forEach((argValue, idx) => {
-                let isCtx = false;
-                // TODO: we assume the first argument is always a context, need a more robust way to test it.
-                if (idx === 0 && passContext) {
-                    // Context -- I suppose we could just instanceof
-                    opCtx = validatedArgs[0];
-                    isCtx = true;
-                }
-                let loggedArgValue = argValue;
-                if (isCtx || methReg.args[idx].logMask === LogMasks.SKIP) {
-                    return;
-                }
-                else {
-                    if (methReg.args[idx].logMask !== LogMasks.NONE) {
-                        // For now this means hash
-                        if (methReg.args[idx].dataType?.dataType === 'json') {
-                            loggedArgValue = generateSaltedHash(JSON.stringify(argValue), 'JSONSALT');
-                        }
-                        else {
-                            // Yes, we are doing the same as above for now.
-                            // It can be better if we have verified the type of the data
-                            loggedArgValue = generateSaltedHash(JSON.stringify(argValue), 'DBOSSALT');
-                        }
-                    }
-                    opCtx?.span.setAttribute(methReg.args[idx].name, loggedArgValue);
-                }
-            });
             return methReg.origFunction.call(this, ...validatedArgs);
         };
         Object.defineProperty(wrappedMethod, 'name', {
             value: methReg.name,
         });
-        descriptor.value = wrappedMethod;
         methReg.registeredFunction = wrappedMethod;
         methodToRegistration.set(methReg.registeredFunction, methReg);
         methodToRegistration.set(methReg.origFunction, methReg);
@@ -577,7 +580,8 @@ function registerAndWrapFunctionTakingContext(target, propertyKey, descriptor) {
     if (!descriptor.value) {
         throw Error('Use of decorator when original method is undefined');
     }
-    const registration = getOrCreateMethodRegistration(target, propertyKey, descriptor, true);
+    const registration = getOrCreateMethodRegistration(target, undefined, propertyKey, descriptor.value, true);
+    descriptor.value = registration.wrappedFunction ?? registration.registeredFunction;
     return { descriptor, registration };
 }
 exports.registerAndWrapFunctionTakingContext = registerAndWrapFunctionTakingContext;
@@ -586,25 +590,63 @@ function registerAndWrapDBOSFunction(target, propertyKey, descriptor) {
     if (!descriptor.value) {
         throw Error('Use of decorator when original method is undefined');
     }
-    const registration = getOrCreateMethodRegistration(target, propertyKey, descriptor, false);
+    const registration = getOrCreateMethodRegistration(target, undefined, propertyKey, descriptor.value, false);
+    descriptor.value = registration.wrappedFunction ?? registration.registeredFunction;
     return { descriptor, registration };
 }
 exports.registerAndWrapDBOSFunction = registerAndWrapDBOSFunction;
+function registerAndWrapDBOSFunctionByName(target, className, funcName, func) {
+    ensureDBOSIsNotLaunched();
+    const registration = getOrCreateMethodRegistration(target, className, funcName, func, false);
+    return { registration };
+}
+exports.registerAndWrapDBOSFunctionByName = registerAndWrapDBOSFunctionByName;
 const classesByName = new Map();
-function getAllRegisteredClasses() {
-    const ctors = [];
-    for (const [_cn, creg] of classesByName) {
-        ctors.push(creg.ctor);
+const classesByCtor = new Map();
+function getNameForClass(ctor) {
+    let regtarget;
+    if (typeof ctor === 'function') {
+        // Static method case
+        regtarget = ctor;
     }
-    return ctors;
+    else {
+        // Instance method case
+        regtarget = ctor.constructor;
+    }
+    if (!classesByCtor.has(regtarget))
+        return regtarget.name;
+    return classesByCtor.get(regtarget).name;
 }
-exports.getAllRegisteredClasses = getAllRegisteredClasses;
+exports.getNameForClass = getNameForClass;
+function getAllRegisteredClassNames() {
+    const cnames = [];
+    for (const [cn, _creg] of classesByName) {
+        cnames.push(cn);
+    }
+    return cnames;
+}
+exports.getAllRegisteredClassNames = getAllRegisteredClassNames;
+function getClassRegistrationByName(name, create = false) {
+    if (!classesByName.has(name) && !create) {
+        throw new error_1.DBOSNotRegisteredError(name, `Class '${name}' is not registered`);
+    }
+    if (!classesByName.has(name)) {
+        classesByName.set(name, { reg: new ClassRegistration() });
+    }
+    const clsReg = classesByName.get(name).reg;
+    if (clsReg.needsInitialized) {
+        clsReg.name = name;
+        clsReg.needsInitialized = false;
+    }
+    return clsReg;
+}
+exports.getClassRegistrationByName = getClassRegistrationByName;
 function getOrCreateClassRegistration(ctor) {
-    const name = ctor.name;
+    const name = getNameForClass(ctor);
     if (!classesByName.has(name)) {
-        classesByName.set(name, new ClassRegistration(ctor));
+        classesByName.set(name, { ctor, reg: new ClassRegistration() });
     }
-    const clsReg = classesByName.get(name);
+    const clsReg = classesByName.get(name).reg;
     if (clsReg.needsInitialized) {
         clsReg.name = name;
         clsReg.needsInitialized = false;
@@ -629,6 +671,12 @@ function associateClassWithEventReceiver(rcvr, ctor) {
     return clsReg.eventReceiverInfo.get(rcvr);
 }
 exports.associateClassWithEventReceiver = associateClassWithEventReceiver;
+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.
@@ -648,91 +696,104 @@ function associateMethodWithEventReceiver(rcvr, target, propertyKey, inDescripto
     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);
+    if (!registration.externalRegInfo.has(external)) {
+        registration.externalRegInfo.set(external, {});
+    }
+    return { registration, regInfo: registration.externalRegInfo.get(external) };
+}
+exports.associateMethodWithExternal = associateMethodWithExternal;
+/*
+ * Associates a DBOS function or method 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);
+    let param;
+    if (typeof paramId === 'number') {
+        param = registration.args[paramId];
+    }
+    else {
+        param = registration.args.find((p) => p.name === paramId);
+    }
+    if (!param)
+        return undefined;
+    if (!param.externalRegInfo.has(external)) {
+        param.externalRegInfo.set(external, {});
+    }
+    return param.externalRegInfo.get(external);
+}
+exports.associateParameterWithExternal = associateParameterWithExternal;
+function getRegistrationsForExternal(external, cls, funcName) {
+    const res = [];
+    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);
+                if (f) {
+                    collectRegForFunction(f);
+                }
+            }
+            else {
+                collectRegForClass(c);
+            }
+        }
+    }
+    else {
+        for (const [_cn, c] of classesByName) {
+            collectRegForClass(c);
+        }
+    }
+    return res;
+    function collectRegForClass(c) {
+        for (const [_fn, f] of c.reg.registeredOperations) {
+            collectRegForFunction(f);
+        }
+    }
+    function collectRegForFunction(f) {
+        const methodConfig = f.externalRegInfo.get(external);
+        const classConfig = f.defaults?.externalRegInfo.get(external);
+        const paramConfig = [];
+        let hasParamConfig = false;
+        for (const arg of f.args) {
+            if (arg.externalRegInfo.has(external))
+                hasParamConfig = true;
+            paramConfig.push({
+                name: arg.name,
+                index: arg.index,
+                paramConfig: arg.externalRegInfo.get(external),
+            });
+        }
+        if (!methodConfig && !classConfig && !hasParamConfig)
+            return;
+        res.push({ methodReg: f, methodConfig, classConfig: classConfig ?? {}, paramConfig });
+    }
+}
+exports.getRegistrationsForExternal = getRegistrationsForExternal;
 //////////////////////////
 /* PARAMETER DECORATORS */
 //////////////////////////
-function ArgRequired(target, propertyKey, parameterIndex) {
-    const existingParameters = getOrCreateMethodArgsRegistration(target, propertyKey);
-    const curParam = existingParameters[parameterIndex];
-    curParam.required = ArgRequiredOptions.REQUIRED;
-}
-exports.ArgRequired = ArgRequired;
-function ArgOptional(target, propertyKey, parameterIndex) {
-    const existingParameters = getOrCreateMethodArgsRegistration(target, propertyKey);
-    const curParam = existingParameters[parameterIndex];
-    curParam.required = ArgRequiredOptions.OPTIONAL;
-}
-exports.ArgOptional = ArgOptional;
-function SkipLogging(target, propertyKey, parameterIndex) {
-    const existingParameters = getOrCreateMethodArgsRegistration(target, propertyKey);
-    const curParam = existingParameters[parameterIndex];
-    curParam.logMask = LogMasks.SKIP;
-}
-exports.SkipLogging = SkipLogging;
-function LogMask(mask) {
-    return function (target, propertyKey, parameterIndex) {
-        const existingParameters = getOrCreateMethodArgsRegistration(target, propertyKey);
-        const curParam = existingParameters[parameterIndex];
-        curParam.logMask = mask;
-    };
-}
-exports.LogMask = LogMask;
 function ArgName(name) {
     return function (target, propertyKey, parameterIndex) {
-        const existingParameters = getOrCreateMethodArgsRegistration(target, propertyKey);
+        const existingParameters = getOrCreateMethodArgsRegistration(target, undefined, propertyKey);
         const curParam = existingParameters[parameterIndex];
         curParam.name = name;
     };
 }
 exports.ArgName = ArgName;
-function ArgDate() {
-    // TODO a little more info about it - is it a date or timestamp precision?
-    return function (target, propertyKey, parameterIndex) {
-        const existingParameters = getOrCreateMethodArgsRegistration(target, propertyKey);
-        const curParam = existingParameters[parameterIndex];
-        if (!curParam.dataType)
-            curParam.dataType = new DBOSDataType();
-        curParam.dataType.dataType = 'timestamp';
-    };
-}
-exports.ArgDate = ArgDate;
-function ArgVarchar(length) {
-    return function (target, propertyKey, parameterIndex) {
-        const existingParameters = getOrCreateMethodArgsRegistration(target, propertyKey);
-        const curParam = existingParameters[parameterIndex];
-        curParam.dataType = DBOSDataType.varchar(length);
-    };
-}
-exports.ArgVarchar = ArgVarchar;
 ///////////////////////
 /* CLASS DECORATORS */
 ///////////////////////
-function DefaultRequiredRole(anyOf) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    function clsdec(ctor) {
-        const clsreg = getOrCreateClassRegistration(ctor);
-        clsreg.requiredRole = anyOf;
-    }
-    return clsdec;
-}
-exports.DefaultRequiredRole = DefaultRequiredRole;
-function DefaultArgRequired(ctor) {
-    const clsreg = getOrCreateClassRegistration(ctor);
-    clsreg.defaultArgRequired = ArgRequiredOptions.REQUIRED;
-    clsreg.argRequiredEnabled = true;
-}
-exports.DefaultArgRequired = DefaultArgRequired;
-function DefaultArgValidate(ctor) {
-    const clsreg = getOrCreateClassRegistration(ctor);
-    clsreg.defaultArgValidate = true;
-}
-exports.DefaultArgValidate = DefaultArgValidate;
-function DefaultArgOptional(ctor) {
-    const clsreg = getOrCreateClassRegistration(ctor);
-    clsreg.defaultArgRequired = ArgRequiredOptions.OPTIONAL;
-    clsreg.argRequiredEnabled = true;
-}
-exports.DefaultArgOptional = DefaultArgOptional;
 /** @deprecated Use `new` */
 function configureInstance(cls, name, ...args) {
     const inst = new cls(name, ...args);
@@ -742,16 +803,6 @@ exports.configureInstance = configureInstance;
 ///////////////////////
 /* METHOD DECORATORS */
 ///////////////////////
-/** @see `DBOS.requiredRole` */
-function RequiredRole(anyOf) {
-    function apidec(target, propertyKey, inDescriptor) {
-        const { descriptor, registration } = registerAndWrapDBOSFunction(target, propertyKey, inDescriptor);
-        registration.requiredRole = anyOf;
-        return descriptor;
-    }
-    return apidec;
-}
-exports.RequiredRole = RequiredRole;
 /**
  * @deprecated Use `@DBOS.workflow`
  * To upgrade to DBOS 2.0+ syntax: