@decaf-ts/transactional-decorators 0.1.1 → 0.1.3

package/lib/decorators.d.ts

@@ -1,19 +1,43 @@
 /**
- * @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
  */
 export declare function transactional(...data: any[]): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;
 /**
- * @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
  */
 export declare function transactionalSuperCall(method: any, ...args: any): any;

package/lib/esm/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/esm/Transaction.js

@@ -1,19 +1,51 @@
 import { Reflection } from "@decaf-ts/reflection";
-import { SyncronousLock } from "./locks/SyncronousLock";
+import { SyncronousLock } from "./locks/SyncronousLock.js";
 import { DBKeys, getAllPropertyDecoratorsRecursive, } from "@decaf-ts/db-decorators";
-import { getObjectName } from "./utils";
-import { TransactionalKeys } from "./constants";
+import { getObjectName } from "./utils.js";
+import { TransactionalKeys } from "./constants.js";
 /**
- * @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 class Transaction {
     constructor(source, method, action, metadata) {
@@ -25,11 +57,12 @@ export 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();
@@ -46,14 +79,18 @@ export 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)
@@ -61,28 +98,36 @@ export 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);
@@ -92,12 +137,10 @@ export 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 = getAllPropertyDecoratorsRecursive(obj, undefined, TransactionalKeys.REFLECT);
@@ -131,7 +174,9 @@ export 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)
@@ -139,21 +184,24 @@ export 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 TransactionalKeys.REFLECT + key;
     }
 }
-//# 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/esm/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/esm/constants.js

@@ -1,5 +1,18 @@
+/**
+ * @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 const TransactionalKeys = {
     REFLECT: "model.transactional.",
     TRANSACTIONAL: "transactional",
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBMkI7SUFDdkQsT0FBTyxFQUFFLHNCQUFzQjtJQUMvQixhQUFhLEVBQUUsZUFBZTtDQUMvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IFRyYW5zYWN0aW9uYWxLZXlzOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+ID0ge1xuICBSRUZMRUNUOiBcIm1vZGVsLnRyYW5zYWN0aW9uYWwuXCIsXG4gIFRSQU5TQUNUSU9OQUw6IFwidHJhbnNhY3Rpb25hbFwiLFxufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUVIOzs7Ozs7R0FNRztBQUNILE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUEyQjtJQUN2RCxPQUFPLEVBQUUsc0JBQXNCO0lBQy9CLGFBQWEsRUFBRSxlQUFlO0NBQy9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEB0eXBlZGVmIHtPYmplY3R9IFRyYW5zYWN0aW9uYWxLZXlzVHlwZVxuICogQHByb3BlcnR5IHtzdHJpbmd9IFJFRkxFQ1QgLSBLZXkgdXNlZCBmb3IgcmVmbGVjdGlvbiBtZXRhZGF0YSByZWxhdGVkIHRvIHRyYW5zYWN0aW9uYWwgbW9kZWxzXG4gKiBAcHJvcGVydHkge3N0cmluZ30gVFJBTlNBQ1RJT05BTCAtIEtleSB1c2VkIHRvIGlkZW50aWZ5IHRyYW5zYWN0aW9uYWwgcHJvcGVydGllc1xuICogQG1lbWJlck9mIG1vZHVsZTp0cmFuc2FjdGlvbnNcbiAqL1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBLZXlzIHVzZWQgZm9yIHRyYW5zYWN0aW9uYWwgb3BlcmF0aW9uc1xuICogQHN1bW1hcnkgQ29uc3RhbnQgb2JqZWN0IGNvbnRhaW5pbmcgc3RyaW5nIGtleXMgdXNlZCB0aHJvdWdob3V0IHRoZSB0cmFuc2FjdGlvbmFsIHN5c3RlbSBmb3IgcmVmbGVjdGlvbiBhbmQgaWRlbnRpZmljYXRpb25cbiAqIEB0eXBlIHtUcmFuc2FjdGlvbmFsS2V5c1R5cGV9XG4gKiBAY29uc3QgVHJhbnNhY3Rpb25hbEtleXNcbiAqIEBtZW1iZXJPZiBtb2R1bGU6dHJhbnNhY3Rpb25zXG4gKi9cbmV4cG9ydCBjb25zdCBUcmFuc2FjdGlvbmFsS2V5czogUmVjb3JkPHN0cmluZywgc3RyaW5nPiA9IHtcbiAgUkVGTEVDVDogXCJtb2RlbC50cmFuc2FjdGlvbmFsLlwiLFxuICBUUkFOU0FDVElPTkFMOiBcInRyYW5zYWN0aW9uYWxcIixcbn07XG4iXX0=

package/lib/esm/decorators.d.ts

@@ -1,19 +1,43 @@
 /**
- * @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
  */
 export declare function transactional(...data: any[]): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;
 /**
- * @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
  */
 export declare function transactionalSuperCall(method: any, ...args: any): any;