@decaf-ts/transactional-decorators 0.1.2 → 0.1.3

package/lib/Transaction.cjs

@@ -7,16 +7,48 @@ const db_decorators_1 = require("@decaf-ts/db-decorators");
 const utils_1 = require("./utils.cjs");
 const constants_1 = require("./constants.cjs");
 /**
- * @summary Transaction Class
- *
- * @param {string} source
- * @param {string} [method]
- * @param {function(): void} [action]
- * @param {any[]} [metadata]
- *
+ * @description Core transaction management class
+ * @summary Manages transaction lifecycle, including creation, execution, and cleanup. Provides mechanisms for binding transactions to objects and methods, ensuring proper transaction context propagation.
+ * @param {string} source - The source/origin of the transaction (typically a class name)
+ * @param {string} [method] - The method name associated with the transaction
+ * @param {function(): any} [action] - The function to execute within the transaction
+ * @param {any[]} [metadata] - Additional metadata to associate with the transaction
  * @class Transaction
+ * @example
+ * // Creating and submitting a transaction
+ * const transaction = new Transaction(
+ *   'UserService',
+ *   'createUser',
+ *   async () => {
+ *     // Transaction logic here
+ *     await db.insert('users', { name: 'John' });
+ *   }
+ * );
+ * Transaction.submit(transaction);
  *
- * @category Transactions
+ * // Using the transactional decorator
+ * class UserService {
+ *   @transactional()
+ *   async createUser(data) {
+ *     // Method will be executed within a transaction
+ *     return await db.insert('users', data);
+ *   }
+ * }
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client Code
+ *   participant T as Transaction
+ *   participant L as TransactionLock
+ *   participant O as Original Method
+ *
+ *   C->>T: new Transaction(source, method, action)
+ *   C->>T: Transaction.submit(transaction)
+ *   T->>L: submit(transaction)
+ *   L->>T: fire()
+ *   T->>O: Execute action()
+ *   O-->>T: Return result/error
+ *   T->>L: release(error?)
+ *   L-->>C: Return result/error
  */
 class Transaction {
     constructor(source, method, action, metadata) {
@@ -28,11 +60,12 @@ class Transaction {
         this.metadata = metadata;
     }
     /**
-     * @summary Pushes a transaction to que queue and waits its resolution
-     *
-     * @param {any} issuer any class. will be used as this when calling the callbackMethod
-     * @param {Function} callbackMethod callback function containing the transaction. will be called with the issuear as this
-     * @param {any[]} args arguments to pass to the method. Last one must be the callback
+     * @description Queues a transaction for execution
+     * @summary Pushes a transaction to the queue and waits for its resolution. Creates a new transaction with the provided issuer and callback method, then submits it to the transaction lock.
+     * @param {any} issuer - Any class instance that will be used as 'this' when calling the callbackMethod
+     * @param {Function} callbackMethod - Callback function containing the transaction logic, will be called with the issuer as 'this'
+     * @param {any[]} args - Arguments to pass to the method. Last one must be the callback function
+     * @return {void}
      */
     static push(issuer, callbackMethod, ...args) {
         const callback = args.pop();
@@ -49,14 +82,18 @@ class Transaction {
         Transaction.getLock().submit(transaction);
     }
     /**
-     * @summary Sets the lock to be used
-     * @param lock
+     * @description Configures the transaction lock implementation
+     * @summary Sets the lock implementation to be used for transaction management, allowing customization of the transaction behavior
+     * @param {TransactionLock} lock - The lock implementation to use for managing transactions
+     * @return {void}
      */
     static setLock(lock) {
         this.lock = lock;
     }
     /**
-     * @summary gets the lock
+     * @description Retrieves the current transaction lock
+     * @summary Gets the current transaction lock instance, creating a default SyncronousLock if none exists
+     * @return {TransactionLock} The current transaction lock implementation
      */
     static getLock() {
         if (!this.lock)
@@ -64,28 +101,36 @@ class Transaction {
         return this.lock;
     }
     /**
-     * @summary submits a transaction
-     * @param {Transaction} transaction
+     * @description Submits a transaction for processing
+     * @summary Submits a transaction to the current transaction lock for processing and execution
+     * @param {Transaction} transaction - The transaction to submit for processing
+     * @return {void}
      */
     static submit(transaction) {
         Transaction.getLock().submit(transaction);
     }
     /**
-     * @summary releases the lock
-     * @param {Err} err
+     * @description Releases the transaction lock
+     * @summary Releases the current transaction lock, optionally with an error, allowing the next transaction to proceed
+     * @param {Error} [err] - Optional error that occurred during transaction execution
+     * @return {Promise<void>} A promise that resolves when the lock has been released
      */
     static async release(err) {
         return Transaction.getLock().release(err);
     }
     /**
-     * @summary retrieves the metadata for the transaction
+     * @description Retrieves transaction metadata
+     * @summary Returns a copy of the metadata associated with this transaction, ensuring the original metadata remains unmodified
+     * @return {any[] | undefined} A copy of the transaction metadata or undefined if no metadata exists
      */
     getMetadata() {
         return this.metadata ? [...this.metadata] : undefined;
     }
     /**
-     * @summary Binds a new operation to the current transaction
-     * @param {Transaction} nextTransaction
+     * @description Links a new transaction to the current one
+     * @summary Binds a new transaction operation to the current transaction, transferring logs and binding methods to maintain transaction context
+     * @param {Transaction} nextTransaction - The new transaction to bind to the current one
+     * @return {void}
      */
     bindTransaction(nextTransaction) {
         // all(`Binding the {0} to {1}`, nextTransaction, this);
@@ -95,12 +140,10 @@ class Transaction {
         this.action = nextTransaction.action;
     }
     /**
-     * @summary Binds the Transactional Decorated Object to the transaction
-     * @description by having all {@link transactional} decorated
-     * methods always pass the current Transaction as an argument
-     *
-     * @param {any} obj
-     * @return {any} the bound {@param obj}
+     * @description Binds an object to the current transaction context
+     * @summary Binds a transactional decorated object to the transaction by ensuring all transactional methods automatically receive the current transaction as their first argument
+     * @param {any} obj - The object to bind to the transaction
+     * @return {any} The bound object with transaction-aware method wrappers
      */
     bindToTransaction(obj) {
         const transactionalMethods = (0, db_decorators_1.getAllPropertyDecoratorsRecursive)(obj, undefined, constants_1.TransactionalKeys.REFLECT);
@@ -134,7 +177,9 @@ class Transaction {
         return boundObj;
     }
     /**
-     * @summary Fires the Transaction
+     * @description Executes the transaction action
+     * @summary Fires the transaction by executing its associated action function, throwing an error if no action is defined
+     * @return {any} The result of the transaction action
      */
     fire() {
         if (!this.action)
@@ -142,22 +187,25 @@ class Transaction {
         return this.action();
     }
     /**
-     * @summary toString override
-     * @param {boolean} [withId] defaults to true
-     * @param {boolean} [withLog] defaults to true
+     * @description Provides a string representation of the transaction
+     * @summary Overrides the default toString method to provide a formatted string representation of the transaction, optionally including the transaction ID and log
+     * @param {boolean} [withId=true] - Whether to include the transaction ID in the output
+     * @param {boolean} [withLog=false] - Whether to include the transaction log in the output
+     * @return {string} A string representation of the transaction
      */
     toString(withId = true, withLog = false) {
         return `${withId ? `[${this.id}]` : ""}[Transaction][${this.source}.${this.method}${withLog ? `]\nTransaction Log:\n${this.log.join("\n")}` : "]"}`;
     }
     /**
-     * @summary gets the transactions reflections key
-     * @function getRepoKey
-     * @param {string} key
-     * @memberOf module:db-decorators.Transactions
-     * */
+     * @description Generates a reflection metadata key for transactions
+     * @summary Creates a prefixed reflection key for transaction-related metadata, ensuring proper namespacing
+     * @param {string} key - The base key to prefix with the transaction reflection namespace
+     * @return {string} The complete reflection key for transaction metadata
+     * @function key
+     */
     static key(key) {
         return constants_1.TransactionalKeys.REFLECT + key;
     }
 }
 exports.Transaction = Transaction;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Transaction.js","sourceRoot":"","sources":["../src/Transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionLock } from \"./interfaces/TransactionLock\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { Callback } from \"./types\";\nimport { SyncronousLock } from \"./locks/SyncronousLock\";\nimport {\n  DBKeys,\n  getAllPropertyDecoratorsRecursive,\n} from \"@decaf-ts/db-decorators\";\nimport { getObjectName } from \"./utils\";\nimport { TransactionalKeys } from \"./constants\";\n\n/**\n * @summary Transaction Class\n *\n * @param {string} source\n * @param {string} [method]\n * @param {function(): void} [action]\n * @param {any[]} [metadata]\n *\n * @class Transaction\n *\n * @category Transactions\n */\nexport class Transaction {\n  readonly id: number;\n  protected action?: () => any;\n  readonly method?: string;\n  readonly source?: string;\n  readonly log: string[];\n  private readonly metadata?: any[];\n\n  private static lock: TransactionLock;\n\n  constructor(\n    source: string,\n    method?: string,\n    action?: () => any,\n    metadata?: any[]\n  ) {\n    this.id = Date.now();\n    this.action = action;\n    this.method = method;\n    this.log = [[this.id, source, method].join(\" | \")];\n    this.source = source;\n    this.metadata = metadata;\n  }\n\n  /**\n   * @summary Pushes a transaction to que queue and waits its resolution\n   *\n   * @param {any} issuer any class. will be used as this when calling the callbackMethod\n   * @param {Function} callbackMethod callback function containing the transaction. will be called with the issuear as this\n   * @param {any[]} args arguments to pass to the method. Last one must be the callback\n   */\n  static push(\n    issuer: any,\n    callbackMethod: (...argzz: (any | Callback)[]) => void,\n    ...args: (any | Callback)[]\n  ) {\n    const callback: Callback = args.pop();\n    if (!callback || typeof callback !== \"function\")\n      throw new Error(\"Missing callback\");\n    const cb = (err?: Error, ...args: any[]) => {\n      Transaction.getLock()\n        .release(err)\n        .then(() => callback(err, ...args));\n    };\n    const transaction: Transaction = new Transaction(\n      issuer.constructor.name,\n      callbackMethod.name ? getObjectName(callbackMethod) : \"Anonymous\",\n      () => {\n        return callbackMethod.call(\n          transaction.bindToTransaction(issuer),\n          ...args,\n          cb\n        );\n      }\n    );\n    Transaction.getLock().submit(transaction);\n  }\n\n  /**\n   * @summary Sets the lock to be used\n   * @param lock\n   */\n  static setLock(lock: TransactionLock) {\n    this.lock = lock;\n  }\n\n  /**\n   * @summary gets the lock\n   */\n  static getLock(): TransactionLock {\n    if (!this.lock) this.lock = new SyncronousLock();\n    return this.lock;\n  }\n\n  /**\n   * @summary submits a transaction\n   * @param {Transaction} transaction\n   */\n  static submit(transaction: Transaction) {\n    Transaction.getLock().submit(transaction);\n  }\n\n  /**\n   * @summary releases the lock\n   * @param {Err} err\n   */\n  static async release(err?: Error) {\n    return Transaction.getLock().release(err);\n  }\n\n  /**\n   * @summary retrieves the metadata for the transaction\n   */\n  getMetadata() {\n    return this.metadata ? [...this.metadata] : undefined;\n  }\n\n  /**\n   * @summary Binds a new operation to the current transaction\n   * @param {Transaction} nextTransaction\n   */\n  bindTransaction(nextTransaction: Transaction) {\n    // all(`Binding the {0} to {1}`, nextTransaction, this);\n    this.log.push(...nextTransaction.log);\n    nextTransaction.bindTransaction = this.bindToTransaction.bind(this);\n    nextTransaction.bindToTransaction = this.bindToTransaction.bind(this);\n    this.action = nextTransaction.action;\n  }\n\n  /**\n   * @summary Binds the Transactional Decorated Object to the transaction\n   * @description by having all {@link transactional} decorated\n   * methods always pass the current Transaction as an argument\n   *\n   * @param {any} obj\n   * @return {any} the bound {@param obj}\n   */\n  bindToTransaction(obj: any): any {\n    const transactionalMethods = getAllPropertyDecoratorsRecursive(\n      obj,\n      undefined,\n      TransactionalKeys.REFLECT\n    );\n    if (!transactionalMethods) return obj;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const self = this;\n\n    const boundObj = Reflection.getAllProperties(obj).reduce(\n      (accum: any, k: string) => {\n        if (\n          Object.keys(transactionalMethods).indexOf(k) !== -1 &&\n          transactionalMethods[k].find(\n            (o) => o.key === TransactionalKeys.TRANSACTIONAL\n          )\n        )\n          accum[k] = (...args: any[]) =>\n            obj[k].call(obj.__originalObj || obj, self, ...args);\n        else if (k === \"clazz\" || k === \"constructor\") accum[k] = obj[k];\n        else if (typeof obj[k] === \"function\")\n          accum[k] = obj[k].bind(obj.__originalObj || obj);\n        else if (typeof obj[k] === \"object\" && obj[k].constructor) {\n          const decs = Reflection.getClassDecorators(\n            TransactionalKeys.REFLECT,\n            obj[k]\n          );\n          if (decs.find((e: any) => e.key === TransactionalKeys.TRANSACTIONAL))\n            accum[k] = self.bindToTransaction(obj[k]);\n          else accum[k] = obj[k];\n        } else accum[k] = obj[k];\n\n        return accum;\n      },\n      {}\n    );\n\n    boundObj[DBKeys.ORIGINAL] = obj[DBKeys.ORIGINAL] || obj;\n    boundObj.toString = () =>\n      getObjectName(boundObj[DBKeys.ORIGINAL]) +\n      \" proxy for transaction \" +\n      this.id;\n\n    return boundObj;\n  }\n\n  /**\n   * @summary Fires the Transaction\n   */\n  fire() {\n    if (!this.action) throw new Error(`Missing the method`);\n    return this.action();\n  }\n\n  /**\n   * @summary toString override\n   * @param {boolean} [withId] defaults to true\n   * @param {boolean} [withLog] defaults to true\n   */\n  toString(withId = true, withLog = false) {\n    return `${withId ? `[${this.id}]` : \"\"}[Transaction][${this.source}.${this.method}${\n      withLog ? `]\\nTransaction Log:\\n${this.log.join(\"\\n\")}` : \"]\"\n    }`;\n  }\n\n  /**\n   * @summary gets the transactions reflections key\n   * @function getRepoKey\n   * @param {string} key\n   * @memberOf module:db-decorators.Transactions\n   * */\n  static key(key: string) {\n    return TransactionalKeys.REFLECT + key;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Transaction.js","sourceRoot":"","sources":["../src/Transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionLock } from \"./interfaces/TransactionLock\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { Callback } from \"./types\";\nimport { SyncronousLock } from \"./locks/SyncronousLock\";\nimport {\n  DBKeys,\n  getAllPropertyDecoratorsRecursive,\n} from \"@decaf-ts/db-decorators\";\nimport { getObjectName } from \"./utils\";\nimport { TransactionalKeys } from \"./constants\";\n\n/**\n * @description Core transaction management class\n * @summary Manages transaction lifecycle, including creation, execution, and cleanup. Provides mechanisms for binding transactions to objects and methods, ensuring proper transaction context propagation.\n * @param {string} source - The source/origin of the transaction (typically a class name)\n * @param {string} [method] - The method name associated with the transaction\n * @param {function(): any} [action] - The function to execute within the transaction\n * @param {any[]} [metadata] - Additional metadata to associate with the transaction\n * @class Transaction\n * @example\n * // Creating and submitting a transaction\n * const transaction = new Transaction(\n *   'UserService',\n *   'createUser',\n *   async () => {\n *     // Transaction logic here\n *     await db.insert('users', { name: 'John' });\n *   }\n * );\n * Transaction.submit(transaction);\n * \n * // Using the transactional decorator\n * class UserService {\n *   @transactional()\n *   async createUser(data) {\n *     // Method will be executed within a transaction\n *     return await db.insert('users', data);\n *   }\n * }\n * @mermaid\n * sequenceDiagram\n *   participant C as Client Code\n *   participant T as Transaction\n *   participant L as TransactionLock\n *   participant O as Original Method\n *   \n *   C->>T: new Transaction(source, method, action)\n *   C->>T: Transaction.submit(transaction)\n *   T->>L: submit(transaction)\n *   L->>T: fire()\n *   T->>O: Execute action()\n *   O-->>T: Return result/error\n *   T->>L: release(error?)\n *   L-->>C: Return result/error\n */\nexport class Transaction {\n  readonly id: number;\n  protected action?: () => any;\n  readonly method?: string;\n  readonly source?: string;\n  readonly log: string[];\n  private readonly metadata?: any[];\n\n  private static lock: TransactionLock;\n\n  constructor(\n    source: string,\n    method?: string,\n    action?: () => any,\n    metadata?: any[]\n  ) {\n    this.id = Date.now();\n    this.action = action;\n    this.method = method;\n    this.log = [[this.id, source, method].join(\" | \")];\n    this.source = source;\n    this.metadata = metadata;\n  }\n\n  /**\n   * @description Queues a transaction for execution\n   * @summary Pushes a transaction to the queue and waits for its resolution. Creates a new transaction with the provided issuer and callback method, then submits it to the transaction lock.\n   * @param {any} issuer - Any class instance that will be used as 'this' when calling the callbackMethod\n   * @param {Function} callbackMethod - Callback function containing the transaction logic, will be called with the issuer as 'this'\n   * @param {any[]} args - Arguments to pass to the method. Last one must be the callback function\n   * @return {void}\n   */\n  static push(\n    issuer: any,\n    callbackMethod: (...argzz: (any | Callback)[]) => void,\n    ...args: (any | Callback)[]\n  ) {\n    const callback: Callback = args.pop();\n    if (!callback || typeof callback !== \"function\")\n      throw new Error(\"Missing callback\");\n    const cb = (err?: Error, ...args: any[]) => {\n      Transaction.getLock()\n        .release(err)\n        .then(() => callback(err, ...args));\n    };\n    const transaction: Transaction = new Transaction(\n      issuer.constructor.name,\n      callbackMethod.name ? getObjectName(callbackMethod) : \"Anonymous\",\n      () => {\n        return callbackMethod.call(\n          transaction.bindToTransaction(issuer),\n          ...args,\n          cb\n        );\n      }\n    );\n    Transaction.getLock().submit(transaction);\n  }\n\n  /**\n   * @description Configures the transaction lock implementation\n   * @summary Sets the lock implementation to be used for transaction management, allowing customization of the transaction behavior\n   * @param {TransactionLock} lock - The lock implementation to use for managing transactions\n   * @return {void}\n   */\n  static setLock(lock: TransactionLock) {\n    this.lock = lock;\n  }\n\n  /**\n   * @description Retrieves the current transaction lock\n   * @summary Gets the current transaction lock instance, creating a default SyncronousLock if none exists\n   * @return {TransactionLock} The current transaction lock implementation\n   */\n  static getLock(): TransactionLock {\n    if (!this.lock) this.lock = new SyncronousLock();\n    return this.lock;\n  }\n\n  /**\n   * @description Submits a transaction for processing\n   * @summary Submits a transaction to the current transaction lock for processing and execution\n   * @param {Transaction} transaction - The transaction to submit for processing\n   * @return {void}\n   */\n  static submit(transaction: Transaction) {\n    Transaction.getLock().submit(transaction);\n  }\n\n  /**\n   * @description Releases the transaction lock\n   * @summary Releases the current transaction lock, optionally with an error, allowing the next transaction to proceed\n   * @param {Error} [err] - Optional error that occurred during transaction execution\n   * @return {Promise<void>} A promise that resolves when the lock has been released\n   */\n  static async release(err?: Error) {\n    return Transaction.getLock().release(err);\n  }\n\n  /**\n   * @description Retrieves transaction metadata\n   * @summary Returns a copy of the metadata associated with this transaction, ensuring the original metadata remains unmodified\n   * @return {any[] | undefined} A copy of the transaction metadata or undefined if no metadata exists\n   */\n  getMetadata() {\n    return this.metadata ? [...this.metadata] : undefined;\n  }\n\n  /**\n   * @description Links a new transaction to the current one\n   * @summary Binds a new transaction operation to the current transaction, transferring logs and binding methods to maintain transaction context\n   * @param {Transaction} nextTransaction - The new transaction to bind to the current one\n   * @return {void}\n   */\n  bindTransaction(nextTransaction: Transaction) {\n    // all(`Binding the {0} to {1}`, nextTransaction, this);\n    this.log.push(...nextTransaction.log);\n    nextTransaction.bindTransaction = this.bindToTransaction.bind(this);\n    nextTransaction.bindToTransaction = this.bindToTransaction.bind(this);\n    this.action = nextTransaction.action;\n  }\n\n  /**\n   * @description Binds an object to the current transaction context\n   * @summary Binds a transactional decorated object to the transaction by ensuring all transactional methods automatically receive the current transaction as their first argument\n   * @param {any} obj - The object to bind to the transaction\n   * @return {any} The bound object with transaction-aware method wrappers\n   */\n  bindToTransaction(obj: any): any {\n    const transactionalMethods = getAllPropertyDecoratorsRecursive(\n      obj,\n      undefined,\n      TransactionalKeys.REFLECT\n    );\n    if (!transactionalMethods) return obj;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const self = this;\n\n    const boundObj = Reflection.getAllProperties(obj).reduce(\n      (accum: any, k: string) => {\n        if (\n          Object.keys(transactionalMethods).indexOf(k) !== -1 &&\n          transactionalMethods[k].find(\n            (o) => o.key === TransactionalKeys.TRANSACTIONAL\n          )\n        )\n          accum[k] = (...args: any[]) =>\n            obj[k].call(obj.__originalObj || obj, self, ...args);\n        else if (k === \"clazz\" || k === \"constructor\") accum[k] = obj[k];\n        else if (typeof obj[k] === \"function\")\n          accum[k] = obj[k].bind(obj.__originalObj || obj);\n        else if (typeof obj[k] === \"object\" && obj[k].constructor) {\n          const decs = Reflection.getClassDecorators(\n            TransactionalKeys.REFLECT,\n            obj[k]\n          );\n          if (decs.find((e: any) => e.key === TransactionalKeys.TRANSACTIONAL))\n            accum[k] = self.bindToTransaction(obj[k]);\n          else accum[k] = obj[k];\n        } else accum[k] = obj[k];\n\n        return accum;\n      },\n      {}\n    );\n\n    boundObj[DBKeys.ORIGINAL] = obj[DBKeys.ORIGINAL] || obj;\n    boundObj.toString = () =>\n      getObjectName(boundObj[DBKeys.ORIGINAL]) +\n      \" proxy for transaction \" +\n      this.id;\n\n    return boundObj;\n  }\n\n  /**\n   * @description Executes the transaction action\n   * @summary Fires the transaction by executing its associated action function, throwing an error if no action is defined\n   * @return {any} The result of the transaction action\n   */\n  fire() {\n    if (!this.action) throw new Error(`Missing the method`);\n    return this.action();\n  }\n\n  /**\n   * @description Provides a string representation of the transaction\n   * @summary Overrides the default toString method to provide a formatted string representation of the transaction, optionally including the transaction ID and log\n   * @param {boolean} [withId=true] - Whether to include the transaction ID in the output\n   * @param {boolean} [withLog=false] - Whether to include the transaction log in the output\n   * @return {string} A string representation of the transaction\n   */\n  toString(withId = true, withLog = false) {\n    return `${withId ? `[${this.id}]` : \"\"}[Transaction][${this.source}.${this.method}${\n      withLog ? `]\\nTransaction Log:\\n${this.log.join(\"\\n\")}` : \"]\"\n    }`;\n  }\n\n  /**\n   * @description Generates a reflection metadata key for transactions\n   * @summary Creates a prefixed reflection key for transaction-related metadata, ensuring proper namespacing\n   * @param {string} key - The base key to prefix with the transaction reflection namespace\n   * @return {string} The complete reflection key for transaction metadata\n   * @function key\n   */\n  static key(key: string) {\n    return TransactionalKeys.REFLECT + key;\n  }\n}\n"]}

package/lib/Transaction.d.ts

@@ -1,16 +1,48 @@
 import { TransactionLock } from "./interfaces/TransactionLock";
 import { Callback } from "./types";
 /**
- * @summary Transaction Class
- *
- * @param {string} source
- * @param {string} [method]
- * @param {function(): void} [action]
- * @param {any[]} [metadata]
- *
+ * @description Core transaction management class
+ * @summary Manages transaction lifecycle, including creation, execution, and cleanup. Provides mechanisms for binding transactions to objects and methods, ensuring proper transaction context propagation.
+ * @param {string} source - The source/origin of the transaction (typically a class name)
+ * @param {string} [method] - The method name associated with the transaction
+ * @param {function(): any} [action] - The function to execute within the transaction
+ * @param {any[]} [metadata] - Additional metadata to associate with the transaction
  * @class Transaction
+ * @example
+ * // Creating and submitting a transaction
+ * const transaction = new Transaction(
+ *   'UserService',
+ *   'createUser',
+ *   async () => {
+ *     // Transaction logic here
+ *     await db.insert('users', { name: 'John' });
+ *   }
+ * );
+ * Transaction.submit(transaction);
  *
- * @category Transactions
+ * // Using the transactional decorator
+ * class UserService {
+ *   @transactional()
+ *   async createUser(data) {
+ *     // Method will be executed within a transaction
+ *     return await db.insert('users', data);
+ *   }
+ * }
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client Code
+ *   participant T as Transaction
+ *   participant L as TransactionLock
+ *   participant O as Original Method
+ *
+ *   C->>T: new Transaction(source, method, action)
+ *   C->>T: Transaction.submit(transaction)
+ *   T->>L: submit(transaction)
+ *   L->>T: fire()
+ *   T->>O: Execute action()
+ *   O-->>T: Return result/error
+ *   T->>L: release(error?)
+ *   L-->>C: Return result/error
  */
 export declare class Transaction {
     readonly id: number;
@@ -22,65 +54,81 @@ export declare class Transaction {
     private static lock;
     constructor(source: string, method?: string, action?: () => any, metadata?: any[]);
     /**
-     * @summary Pushes a transaction to que queue and waits its resolution
-     *
-     * @param {any} issuer any class. will be used as this when calling the callbackMethod
-     * @param {Function} callbackMethod callback function containing the transaction. will be called with the issuear as this
-     * @param {any[]} args arguments to pass to the method. Last one must be the callback
+     * @description Queues a transaction for execution
+     * @summary Pushes a transaction to the queue and waits for its resolution. Creates a new transaction with the provided issuer and callback method, then submits it to the transaction lock.
+     * @param {any} issuer - Any class instance that will be used as 'this' when calling the callbackMethod
+     * @param {Function} callbackMethod - Callback function containing the transaction logic, will be called with the issuer as 'this'
+     * @param {any[]} args - Arguments to pass to the method. Last one must be the callback function
+     * @return {void}
      */
     static push(issuer: any, callbackMethod: (...argzz: (any | Callback)[]) => void, ...args: (any | Callback)[]): void;
     /**
-     * @summary Sets the lock to be used
-     * @param lock
+     * @description Configures the transaction lock implementation
+     * @summary Sets the lock implementation to be used for transaction management, allowing customization of the transaction behavior
+     * @param {TransactionLock} lock - The lock implementation to use for managing transactions
+     * @return {void}
      */
     static setLock(lock: TransactionLock): void;
     /**
-     * @summary gets the lock
+     * @description Retrieves the current transaction lock
+     * @summary Gets the current transaction lock instance, creating a default SyncronousLock if none exists
+     * @return {TransactionLock} The current transaction lock implementation
      */
     static getLock(): TransactionLock;
     /**
-     * @summary submits a transaction
-     * @param {Transaction} transaction
+     * @description Submits a transaction for processing
+     * @summary Submits a transaction to the current transaction lock for processing and execution
+     * @param {Transaction} transaction - The transaction to submit for processing
+     * @return {void}
      */
     static submit(transaction: Transaction): void;
     /**
-     * @summary releases the lock
-     * @param {Err} err
+     * @description Releases the transaction lock
+     * @summary Releases the current transaction lock, optionally with an error, allowing the next transaction to proceed
+     * @param {Error} [err] - Optional error that occurred during transaction execution
+     * @return {Promise<void>} A promise that resolves when the lock has been released
      */
     static release(err?: Error): Promise<void>;
     /**
-     * @summary retrieves the metadata for the transaction
+     * @description Retrieves transaction metadata
+     * @summary Returns a copy of the metadata associated with this transaction, ensuring the original metadata remains unmodified
+     * @return {any[] | undefined} A copy of the transaction metadata or undefined if no metadata exists
      */
     getMetadata(): any[] | undefined;
     /**
-     * @summary Binds a new operation to the current transaction
-     * @param {Transaction} nextTransaction
+     * @description Links a new transaction to the current one
+     * @summary Binds a new transaction operation to the current transaction, transferring logs and binding methods to maintain transaction context
+     * @param {Transaction} nextTransaction - The new transaction to bind to the current one
+     * @return {void}
      */
     bindTransaction(nextTransaction: Transaction): void;
     /**
-     * @summary Binds the Transactional Decorated Object to the transaction
-     * @description by having all {@link transactional} decorated
-     * methods always pass the current Transaction as an argument
-     *
-     * @param {any} obj
-     * @return {any} the bound {@param obj}
+     * @description Binds an object to the current transaction context
+     * @summary Binds a transactional decorated object to the transaction by ensuring all transactional methods automatically receive the current transaction as their first argument
+     * @param {any} obj - The object to bind to the transaction
+     * @return {any} The bound object with transaction-aware method wrappers
      */
     bindToTransaction(obj: any): any;
     /**
-     * @summary Fires the Transaction
+     * @description Executes the transaction action
+     * @summary Fires the transaction by executing its associated action function, throwing an error if no action is defined
+     * @return {any} The result of the transaction action
      */
     fire(): any;
     /**
-     * @summary toString override
-     * @param {boolean} [withId] defaults to true
-     * @param {boolean} [withLog] defaults to true
+     * @description Provides a string representation of the transaction
+     * @summary Overrides the default toString method to provide a formatted string representation of the transaction, optionally including the transaction ID and log
+     * @param {boolean} [withId=true] - Whether to include the transaction ID in the output
+     * @param {boolean} [withLog=false] - Whether to include the transaction log in the output
+     * @return {string} A string representation of the transaction
      */
     toString(withId?: boolean, withLog?: boolean): string;
     /**
-     * @summary gets the transactions reflections key
-     * @function getRepoKey
-     * @param {string} key
-     * @memberOf module:db-decorators.Transactions
-     * */
+     * @description Generates a reflection metadata key for transactions
+     * @summary Creates a prefixed reflection key for transaction-related metadata, ensuring proper namespacing
+     * @param {string} key - The base key to prefix with the transaction reflection namespace
+     * @return {string} The complete reflection key for transaction metadata
+     * @function key
+     */
     static key(key: string): string;
 }

package/lib/constants.cjs

@@ -1,8 +1,21 @@
 "use strict";
+/**
+ * @typedef {Object} TransactionalKeysType
+ * @property {string} REFLECT - Key used for reflection metadata related to transactional models
+ * @property {string} TRANSACTIONAL - Key used to identify transactional properties
+ * @memberOf module:transactions
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionalKeys = void 0;
+/**
+ * @description Keys used for transactional operations
+ * @summary Constant object containing string keys used throughout the transactional system for reflection and identification
+ * @type {TransactionalKeysType}
+ * @const TransactionalKeys
+ * @memberOf module:transactions
+ */
 exports.TransactionalKeys = {
     REFLECT: "model.transactional.",
     TRANSACTIONAL: "transactional",
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLGlCQUFpQixHQUEyQjtJQUN2RCxPQUFPLEVBQUUsc0JBQXNCO0lBQy9CLGFBQWEsRUFBRSxlQUFlO0NBQy9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgVHJhbnNhY3Rpb25hbEtleXM6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gPSB7XG4gIFJFRkxFQ1Q6IFwibW9kZWwudHJhbnNhY3Rpb25hbC5cIixcbiAgVFJBTlNBQ1RJT05BTDogXCJ0cmFuc2FjdGlvbmFsXCIsXG59O1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7O0dBS0c7OztBQUVIOzs7Ozs7R0FNRztBQUNVLFFBQUEsaUJBQWlCLEdBQTJCO0lBQ3ZELE9BQU8sRUFBRSxzQkFBc0I7SUFDL0IsYUFBYSxFQUFFLGVBQWU7Q0FDL0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQHR5cGVkZWYge09iamVjdH0gVHJhbnNhY3Rpb25hbEtleXNUeXBlXG4gKiBAcHJvcGVydHkge3N0cmluZ30gUkVGTEVDVCAtIEtleSB1c2VkIGZvciByZWZsZWN0aW9uIG1ldGFkYXRhIHJlbGF0ZWQgdG8gdHJhbnNhY3Rpb25hbCBtb2RlbHNcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBUUkFOU0FDVElPTkFMIC0gS2V5IHVzZWQgdG8gaWRlbnRpZnkgdHJhbnNhY3Rpb25hbCBwcm9wZXJ0aWVzXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnRyYW5zYWN0aW9uc1xuICovXG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEtleXMgdXNlZCBmb3IgdHJhbnNhY3Rpb25hbCBvcGVyYXRpb25zXG4gKiBAc3VtbWFyeSBDb25zdGFudCBvYmplY3QgY29udGFpbmluZyBzdHJpbmcga2V5cyB1c2VkIHRocm91Z2hvdXQgdGhlIHRyYW5zYWN0aW9uYWwgc3lzdGVtIGZvciByZWZsZWN0aW9uIGFuZCBpZGVudGlmaWNhdGlvblxuICogQHR5cGUge1RyYW5zYWN0aW9uYWxLZXlzVHlwZX1cbiAqIEBjb25zdCBUcmFuc2FjdGlvbmFsS2V5c1xuICogQG1lbWJlck9mIG1vZHVsZTp0cmFuc2FjdGlvbnNcbiAqL1xuZXhwb3J0IGNvbnN0IFRyYW5zYWN0aW9uYWxLZXlzOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+ID0ge1xuICBSRUZMRUNUOiBcIm1vZGVsLnRyYW5zYWN0aW9uYWwuXCIsXG4gIFRSQU5TQUNUSU9OQUw6IFwidHJhbnNhY3Rpb25hbFwiLFxufTtcbiJdfQ==

package/lib/constants.d.ts

@@ -1 +1,14 @@
+/**
+ * @typedef {Object} TransactionalKeysType
+ * @property {string} REFLECT - Key used for reflection metadata related to transactional models
+ * @property {string} TRANSACTIONAL - Key used to identify transactional properties
+ * @memberOf module:transactions
+ */
+/**
+ * @description Keys used for transactional operations
+ * @summary Constant object containing string keys used throughout the transactional system for reflection and identification
+ * @type {TransactionalKeysType}
+ * @const TransactionalKeys
+ * @memberOf module:transactions
+ */
 export declare const TransactionalKeys: Record<string, string>;

package/lib/decorators.cjs

@@ -7,13 +7,36 @@ const reflection_1 = require("@decaf-ts/reflection");
 const Transaction_1 = require("./Transaction.cjs");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
 /**
- * @summary Sets a class Async method as transactional
+ * @description Method decorator that enables transactional behavior
+ * @summary Sets a class async method as transactional, wrapping it in a transaction context that can be managed by the transaction system. This decorator handles transaction creation, binding, and error handling.
+ * @param {any[]} [data] - Optional metadata available to the {@link TransactionLock} implementation
+ * @return {Function} A decorator function that wraps the original method with transactional behavior
+ * @function transactional
+ * @category Method Decorators
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client Code
+ *   participant D as Decorator
+ *   participant T as Transaction
+ *   participant O as Original Method
  *
- * @param {any[]}  [data] option metadata available to the {@link TransactionLock}
+ *   C->>D: Call decorated method
+ *   D->>D: Check if transaction exists in args
  *
- * @function transactional
+ *   alt Transaction exists in args
+ *     D->>T: Create updated transaction
+ *     T->>T: Bind to original transaction
+ *     T->>T: Fire transaction
+ *   else No transaction
+ *     D->>T: Create new transaction
+ *     T->>T: Submit transaction
+ *   end
  *
- * @memberOf module:db-decorators.Decorators.transactions
+ *   T->>O: Execute original method
+ *   O-->>T: Return result/error
+ *   T->>T: Release transaction
+ *   T-->>C: Return result/error
+ * @category Decorators
  */
 function transactional(...data) {
     return function (target, propertyKey, descriptor) {
@@ -152,16 +175,17 @@ function transactional(...data) {
 //   };
 // }
 /**
- * @summary Util function to wrap super calls with the transaction when the super's method is also transactional
- *
- * @param {Function} method the super method (must be bound to the proper this), eg: super.create.bind(this)
- * @param {any[]} args the arguments to call the method with
- *
- * @memberOf module:db-decorators.Transaction
+ * @description Utility for handling super calls in transactional methods
+ * @summary Wraps super method calls with the current transaction context when the super's method is also transactional, ensuring transaction continuity through the inheritance chain
+ * @param {Function} method - The super method (must be bound to the proper this), e.g., super.create.bind(this)
+ * @param {any[]} args - The arguments to call the method with
+ * @return {any} The result of the super method call
+ * @function transactionalSuperCall
+ * @memberOf module:transactions
  */
 function transactionalSuperCall(method, ...args) {
     const lock = Transaction_1.Transaction.getLock();
     const currentTransaction = lock.currentTransaction;
     return method(currentTransaction, ...args);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionalKeys } from \"./constants\";\nimport { metadata } from \"@decaf-ts/reflection\";\nimport { Transaction } from \"./Transaction\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @summary Sets a class Async method as transactional\n *\n * @param {any[]}  [data] option metadata available to the {@link TransactionLock}\n *\n * @function transactional\n *\n * @memberOf module:db-decorators.Decorators.transactions\n */\nexport function transactional(...data: any[]) {\n  return function (\n    target: any,\n    propertyKey?: any,\n    descriptor?: PropertyDescriptor\n  ) {\n    if (!descriptor)\n      throw new InternalError(\"Missing descriptor. Should be impossible\");\n    metadata(Transaction.key(TransactionalKeys.TRANSACTIONAL), data)(\n      target,\n      propertyKey\n    );\n\n    const originalMethod = descriptor.value;\n\n    const methodWrapper = function (this: any, ...args: any[]): Promise<any> {\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      const self = this;\n      return new Promise<any>((resolve, reject) => {\n        const cb = (err?: Error, result?: any) => {\n          Transaction.release(err).then(() => {\n            if (err) return reject(err);\n            resolve(result);\n          });\n        };\n\n        let transaction = args.shift();\n        if (transaction instanceof Transaction) {\n          const updatedTransaction: Transaction = new Transaction(\n            this.constructor.name,\n            propertyKey,\n            async () => {\n              originalMethod\n                .call(updatedTransaction.bindToTransaction(self), ...args)\n                .then(resolve)\n                .catch(reject);\n            },\n            data.length ? data : undefined\n          );\n\n          transaction.bindTransaction(updatedTransaction);\n          transaction.fire();\n        } else {\n          args.unshift(transaction);\n          transaction = new Transaction(\n            this.constructor.name,\n            propertyKey,\n            () => {\n              originalMethod\n                .call(transaction.bindToTransaction(self), ...args)\n                .then((result: any) => cb(undefined, result))\n                .catch(cb);\n            },\n            data.length ? data : undefined\n          );\n          Transaction.submit(transaction);\n        }\n      });\n    };\n\n    Object.defineProperty(methodWrapper, \"name\", {\n      value: propertyKey,\n    });\n    descriptor.value = methodWrapper;\n  };\n}\n//\n// /**\n//  * @summary Sets a class Async method as transactional\n//  *\n//  * @param {any[]}  [metadata] option metadata available to the {@link TransactionLock}\n//  *\n//  * @function transactionalAsync\n//  *\n//  * @memberOf module:db-decorators.Decorators.transactions\n//  */\n// export function transactionalAsync(...metadata: any[]) {\n//   return function (\n//     target: any,\n//     propertyKey: string,\n//     descriptor: PropertyDescriptor,\n//   ) {\n//     metadasta(getTransactionalKey(TransactionalKeys.TRANSACTIONAL))\n//     Reflect.defineMetadata(\n//       ,\n//       {\n//         type: \"async\",\n//         metadata: metadata.length ? metadata : undefined,\n//       } as TransactionalMetadata,\n//       target,\n//       propertyKey,\n//     );\n//\n//     const originalMethod = descriptor.value;\n//\n//     const methodWrapper = function (this: any, ...args: any[]) {\n//       const callback: Callback = args.pop();\n//       if (!callback || typeof callback !== \"function\")\n//         throw new CriticalError(`Missing Callback`);\n//\n//       const cb = (err?: Err, ...args: any[]) => {\n//         Transaction.release(err).then((_) => callback(err, ...args));\n//       };\n//\n//       const self = this;\n//\n//       let transaction = args.shift();\n//       if (transaction instanceof Transaction) {\n//         const updatedTransaction: Transaction = new Transaction(\n//           this.constructor.name,\n//           propertyKey,\n//           () => {\n//             try {\n//               return originalMethod.call(\n//                 updatedTransaction.bindToTransaction(self),\n//                 ...args,\n//                 callback,\n//               );\n//             } catch (e: any) {\n//               return callback(e);\n//             }\n//           },\n//           metadata.length ? metadata : undefined,\n//         );\n//\n//         transaction.bindTransaction(updatedTransaction);\n//         transaction.fire();\n//       } else {\n//         args.unshift(transaction);\n//         transaction = undefined;\n//         transaction = new Transaction(\n//           this.constructor.name,\n//           propertyKey,\n//           () => {\n//             try {\n//               return originalMethod.call(\n//                 transaction.bindToTransaction(self),\n//                 ...args,\n//                 cb,\n//               );\n//             } catch (e: any) {\n//               return cb(e);\n//             }\n//           },\n//           metadata.length ? metadata : undefined,\n//         );\n//         Transaction.submit(transaction);\n//       }\n//     };\n//\n//     Object.defineProperty(methodWrapper, \"name\", {\n//       value: propertyKey,\n//     });\n//     descriptor.value = methodWrapper;\n//   };\n// }\n\n/**\n * @summary Util function to wrap super calls with the transaction when the super's method is also transactional\n *\n * @param {Function} method the super method (must be bound to the proper this), eg: super.create.bind(this)\n * @param {any[]} args the arguments to call the method with\n *\n * @memberOf module:db-decorators.Transaction\n */\nexport function transactionalSuperCall(method: any, ...args: any) {\n  const lock = Transaction.getLock();\n  const currentTransaction = lock.currentTransaction;\n  return method(currentTransaction, ...args);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionalKeys } from \"./constants\";\nimport { metadata } from \"@decaf-ts/reflection\";\nimport { Transaction } from \"./Transaction\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Method decorator that enables transactional behavior\n * @summary Sets a class async method as transactional, wrapping it in a transaction context that can be managed by the transaction system. This decorator handles transaction creation, binding, and error handling.\n * @param {any[]} [data] - Optional metadata available to the {@link TransactionLock} implementation\n * @return {Function} A decorator function that wraps the original method with transactional behavior\n * @function transactional\n * @category Method Decorators\n * @mermaid\n * sequenceDiagram\n *   participant C as Client Code\n *   participant D as Decorator\n *   participant T as Transaction\n *   participant O as Original Method\n *\n *   C->>D: Call decorated method\n *   D->>D: Check if transaction exists in args\n *\n *   alt Transaction exists in args\n *     D->>T: Create updated transaction\n *     T->>T: Bind to original transaction\n *     T->>T: Fire transaction\n *   else No transaction\n *     D->>T: Create new transaction\n *     T->>T: Submit transaction\n *   end\n *\n *   T->>O: Execute original method\n *   O-->>T: Return result/error\n *   T->>T: Release transaction\n *   T-->>C: Return result/error\n * @category Decorators\n */\nexport function transactional(...data: any[]) {\n  return function (\n    target: any,\n    propertyKey?: any,\n    descriptor?: PropertyDescriptor\n  ) {\n    if (!descriptor)\n      throw new InternalError(\"Missing descriptor. Should be impossible\");\n    metadata(Transaction.key(TransactionalKeys.TRANSACTIONAL), data)(\n      target,\n      propertyKey\n    );\n\n    const originalMethod = descriptor.value;\n\n    const methodWrapper = function (this: any, ...args: any[]): Promise<any> {\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      const self = this;\n      return new Promise<any>((resolve, reject) => {\n        const cb = (err?: Error, result?: any) => {\n          Transaction.release(err).then(() => {\n            if (err) return reject(err);\n            resolve(result);\n          });\n        };\n\n        let transaction = args.shift();\n        if (transaction instanceof Transaction) {\n          const updatedTransaction: Transaction = new Transaction(\n            this.constructor.name,\n            propertyKey,\n            async () => {\n              originalMethod\n                .call(updatedTransaction.bindToTransaction(self), ...args)\n                .then(resolve)\n                .catch(reject);\n            },\n            data.length ? data : undefined\n          );\n\n          transaction.bindTransaction(updatedTransaction);\n          transaction.fire();\n        } else {\n          args.unshift(transaction);\n          transaction = new Transaction(\n            this.constructor.name,\n            propertyKey,\n            () => {\n              originalMethod\n                .call(transaction.bindToTransaction(self), ...args)\n                .then((result: any) => cb(undefined, result))\n                .catch(cb);\n            },\n            data.length ? data : undefined\n          );\n          Transaction.submit(transaction);\n        }\n      });\n    };\n\n    Object.defineProperty(methodWrapper, \"name\", {\n      value: propertyKey,\n    });\n    descriptor.value = methodWrapper;\n  };\n}\n//\n// /**\n//  * @summary Sets a class Async method as transactional\n//  *\n//  * @param {any[]}  [metadata] option metadata available to the {@link TransactionLock}\n//  *\n//  * @function transactionalAsync\n//  *\n//  * @memberOf module:db-decorators.Decorators.transactions\n//  */\n// export function transactionalAsync(...metadata: any[]) {\n//   return function (\n//     target: any,\n//     propertyKey: string,\n//     descriptor: PropertyDescriptor,\n//   ) {\n//     metadasta(getTransactionalKey(TransactionalKeys.TRANSACTIONAL))\n//     Reflect.defineMetadata(\n//       ,\n//       {\n//         type: \"async\",\n//         metadata: metadata.length ? metadata : undefined,\n//       } as TransactionalMetadata,\n//       target,\n//       propertyKey,\n//     );\n//\n//     const originalMethod = descriptor.value;\n//\n//     const methodWrapper = function (this: any, ...args: any[]) {\n//       const callback: Callback = args.pop();\n//       if (!callback || typeof callback !== \"function\")\n//         throw new CriticalError(`Missing Callback`);\n//\n//       const cb = (err?: Err, ...args: any[]) => {\n//         Transaction.release(err).then((_) => callback(err, ...args));\n//       };\n//\n//       const self = this;\n//\n//       let transaction = args.shift();\n//       if (transaction instanceof Transaction) {\n//         const updatedTransaction: Transaction = new Transaction(\n//           this.constructor.name,\n//           propertyKey,\n//           () => {\n//             try {\n//               return originalMethod.call(\n//                 updatedTransaction.bindToTransaction(self),\n//                 ...args,\n//                 callback,\n//               );\n//             } catch (e: any) {\n//               return callback(e);\n//             }\n//           },\n//           metadata.length ? metadata : undefined,\n//         );\n//\n//         transaction.bindTransaction(updatedTransaction);\n//         transaction.fire();\n//       } else {\n//         args.unshift(transaction);\n//         transaction = undefined;\n//         transaction = new Transaction(\n//           this.constructor.name,\n//           propertyKey,\n//           () => {\n//             try {\n//               return originalMethod.call(\n//                 transaction.bindToTransaction(self),\n//                 ...args,\n//                 cb,\n//               );\n//             } catch (e: any) {\n//               return cb(e);\n//             }\n//           },\n//           metadata.length ? metadata : undefined,\n//         );\n//         Transaction.submit(transaction);\n//       }\n//     };\n//\n//     Object.defineProperty(methodWrapper, \"name\", {\n//       value: propertyKey,\n//     });\n//     descriptor.value = methodWrapper;\n//   };\n// }\n\n/**\n * @description Utility for handling super calls in transactional methods\n * @summary Wraps super method calls with the current transaction context when the super's method is also transactional, ensuring transaction continuity through the inheritance chain\n * @param {Function} method - The super method (must be bound to the proper this), e.g., super.create.bind(this)\n * @param {any[]} args - The arguments to call the method with\n * @return {any} The result of the super method call\n * @function transactionalSuperCall\n * @memberOf module:transactions\n */\nexport function transactionalSuperCall(method: any, ...args: any) {\n  const lock = Transaction.getLock();\n  const currentTransaction = lock.currentTransaction;\n  return method(currentTransaction, ...args);\n}\n"]}