@decaf-ts/transactional-decorators 0.0.21 → 0.1.0

package/dist/transactional-decorators.esm.cjs

@@ -0,0 +1,533 @@
+import { Reflection, metadata } from '@decaf-ts/reflection';
+import { getAllPropertyDecoratorsRecursive, DBKeys, InternalError } from '@decaf-ts/db-decorators';
+
+/**
+ * @summary Simple Promise based Lock class
+ *
+ * @class Lock
+ * @category Transactions
+ */
+class Lock {
+    constructor() {
+        this.queue = [];
+        this.locked = false;
+    }
+    /**
+     * @summary executes when lock is available
+     * @param {Function} func
+     */
+    async execute(func) {
+        await this.acquire();
+        let result;
+        try {
+            result = await Promise.resolve(func());
+        }
+        catch (e) {
+            this.release();
+            throw e;
+        }
+        this.release();
+        return result;
+    }
+    /**
+     * @summary waits to acquire the lock
+     * @param {string} [issuer]
+     */
+    async acquire() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        if (self.locked) {
+            return new Promise((resolve) => self.queue.push(resolve));
+        }
+        else {
+            self.locked = true;
+            return Promise.resolve();
+        }
+    }
+    /**
+     * @summary releases the lock
+     */
+    release() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const next = self.queue.shift();
+        if (next) {
+            if (typeof globalThis.window === "undefined")
+                globalThis.process.nextTick(next); // if you are on node
+            else
+                setTimeout(next, 0); // if you are in the browser
+        }
+        else {
+            self.locked = false;
+        }
+    }
+}
+
+class SyncronousLock {
+    constructor(counter = 1, onBegin, onEnd) {
+        this.currentTransaction = undefined;
+        this.lock = new Lock();
+        this.counter = counter;
+        this.pendingTransactions = [];
+        this.onBegin = onBegin;
+        this.onEnd = onEnd;
+    }
+    /**
+     * @summary Submits a transaction to be processed
+     * @param {Transaction} transaction
+     */
+    submit(transaction) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        self.lock.acquire().then(() => {
+            if (self.currentTransaction &&
+                self.currentTransaction.id === transaction.id) {
+                self.lock.release();
+                return transaction.fire();
+            }
+            if (self.counter > 0) {
+                self.counter--;
+                self.lock.release();
+                return self.fireTransaction(transaction);
+            }
+            else {
+                self.pendingTransactions.push(transaction);
+                self.lock.release();
+            }
+        });
+    }
+    /**
+     * @summary Executes a transaction
+     *
+     * @param {Transaction} transaction
+     * @private
+     */
+    fireTransaction(transaction) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        self.lock.acquire().then(() => {
+            self.currentTransaction = transaction;
+            self.lock.release();
+            if (self.onBegin)
+                self.onBegin().then(() => {
+                    // all.call(
+                    //   self,
+                    //   `Firing transaction {0}. {1} remaining...`,
+                    //   transaction.id,
+                    //   this.pendingTransactions.length,
+                    // );
+                    transaction.fire();
+                });
+            else {
+                // all.call(
+                //   self,
+                //   `Firing transaction {0}. {1} remaining...`,
+                //   transaction.id,
+                //   this.pendingTransactions.length,
+                // );
+                transaction.fire();
+            }
+        });
+    }
+    /**
+     * @summary Releases The lock after the conclusion of a transaction
+     */
+    async release(err) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return new Promise((resolve) => {
+            self.lock.acquire().then(() => {
+                if (!self.currentTransaction)
+                    console.warn("Trying to release an unexisting transaction. should never happen...");
+                // debug.call(
+                //   self,
+                //   "Releasing transaction: {0}",
+                //   self.currentTransaction?.toString(true, true),
+                // );
+                self.currentTransaction = undefined;
+                self.lock.release();
+                const afterConclusionCB = () => {
+                    self.lock.acquire().then(() => {
+                        if (self.pendingTransactions.length > 0) {
+                            const transaction = self.pendingTransactions.shift();
+                            const cb = () => self.fireTransaction(transaction);
+                            //
+                            // all(
+                            //   `Releasing Transaction Lock on transaction {0}`,
+                            //   transaction.id,
+                            // );
+                            if (typeof globalThis.window ===
+                                "undefined")
+                                globalThis.process.nextTick(cb); // if you are on node
+                            else
+                                setTimeout(cb, 0); // if you are in the browser
+                        }
+                        else {
+                            self.counter++;
+                        }
+                        self.lock.release();
+                        resolve();
+                    });
+                };
+                if (self.onEnd)
+                    self.onEnd(err).then(() => afterConclusionCB());
+                else
+                    afterConclusionCB();
+            });
+        });
+    }
+}
+
+const TransactionalKeys = {
+    REFLECT: "model.transactional.",
+    TRANSACTIONAL: "transactional",
+};
+
+function getObjectName(obj) {
+    if (!obj)
+        return;
+    if (typeof obj === "string")
+        return obj;
+    if (obj.constructor &&
+        obj.constructor.name &&
+        ["Function", "Object"].indexOf(obj.constructor.name) === -1)
+        return obj.constructor.name;
+    if (typeof obj === "function" && obj.name)
+        return obj.name;
+    return obj.toString();
+}
+
+/**
+ * @summary Transaction Class
+ *
+ * @param {string} source
+ * @param {string} [method]
+ * @param {function(): void} [action]
+ * @param {any[]} [metadata]
+ *
+ * @class Transaction
+ *
+ * @category Transactions
+ */
+class Transaction {
+    constructor(source, method, action, metadata) {
+        this.id = Date.now();
+        this.action = action;
+        this.method = method;
+        this.log = [[this.id, source, method].join(" | ")];
+        this.source = source;
+        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
+     */
+    static push(issuer, callbackMethod, ...args) {
+        const callback = args.pop();
+        if (!callback || typeof callback !== "function")
+            throw new Error("Missing callback");
+        const cb = (err, ...args) => {
+            Transaction.getLock()
+                .release(err)
+                .then(() => callback(err, ...args));
+        };
+        const transaction = new Transaction(issuer.constructor.name, callbackMethod.name ? getObjectName(callbackMethod) : "Anonymous", () => {
+            return callbackMethod.call(transaction.bindToTransaction(issuer), ...args, cb);
+        });
+        Transaction.getLock().submit(transaction);
+    }
+    /**
+     * @summary Sets the lock to be used
+     * @param lock
+     */
+    static setLock(lock) {
+        this.lock = lock;
+    }
+    /**
+     * @summary gets the lock
+     */
+    static getLock() {
+        if (!this.lock)
+            this.lock = new SyncronousLock();
+        return this.lock;
+    }
+    /**
+     * @summary submits a transaction
+     * @param {Transaction} transaction
+     */
+    static submit(transaction) {
+        Transaction.getLock().submit(transaction);
+    }
+    /**
+     * @summary releases the lock
+     * @param {Err} err
+     */
+    static async release(err) {
+        return Transaction.getLock().release(err);
+    }
+    /**
+     * @summary retrieves the metadata for the transaction
+     */
+    getMetadata() {
+        return this.metadata ? [...this.metadata] : undefined;
+    }
+    /**
+     * @summary Binds a new operation to the current transaction
+     * @param {Transaction} nextTransaction
+     */
+    bindTransaction(nextTransaction) {
+        // all(`Binding the {0} to {1}`, nextTransaction, this);
+        this.log.push(...nextTransaction.log);
+        nextTransaction.bindTransaction = this.bindToTransaction.bind(this);
+        nextTransaction.bindToTransaction = this.bindToTransaction.bind(this);
+        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}
+     */
+    bindToTransaction(obj) {
+        const transactionalMethods = getAllPropertyDecoratorsRecursive(obj, undefined, TransactionalKeys.REFLECT);
+        if (!transactionalMethods)
+            return obj;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const boundObj = Reflection.getAllProperties(obj).reduce((accum, k) => {
+            if (Object.keys(transactionalMethods).indexOf(k) !== -1 &&
+                transactionalMethods[k].find((o) => o.key === TransactionalKeys.TRANSACTIONAL))
+                accum[k] = (...args) => obj[k].call(obj.__originalObj || obj, self, ...args);
+            else if (k === "clazz" || k === "constructor")
+                accum[k] = obj[k];
+            else if (typeof obj[k] === "function")
+                accum[k] = obj[k].bind(obj.__originalObj || obj);
+            else if (typeof obj[k] === "object" && obj[k].constructor) {
+                const decs = Reflection.getClassDecorators(TransactionalKeys.REFLECT, obj[k]);
+                if (decs.find((e) => e.key === TransactionalKeys.TRANSACTIONAL))
+                    accum[k] = self.bindToTransaction(obj[k]);
+                else
+                    accum[k] = obj[k];
+            }
+            else
+                accum[k] = obj[k];
+            return accum;
+        }, {});
+        boundObj[DBKeys.ORIGINAL] = obj[DBKeys.ORIGINAL] || obj;
+        boundObj.toString = () => getObjectName(boundObj[DBKeys.ORIGINAL]) +
+            " proxy for transaction " +
+            this.id;
+        return boundObj;
+    }
+    /**
+     * @summary Fires the Transaction
+     */
+    fire() {
+        if (!this.action)
+            throw new Error(`Missing the method`);
+        return this.action();
+    }
+    /**
+     * @summary toString override
+     * @param {boolean} [withId] defaults to true
+     * @param {boolean} [withLog] defaults to true
+     */
+    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
+     * */
+    static key(key) {
+        return TransactionalKeys.REFLECT + key;
+    }
+}
+
+/**
+ * @summary Sets a class Async method as transactional
+ *
+ * @param {any[]}  [data] option metadata available to the {@link TransactionLock}
+ *
+ * @function transactional
+ *
+ * @memberOf module:db-decorators.Decorators.transactions
+ */
+function transactional(...data) {
+    return function (target, propertyKey, descriptor) {
+        if (!descriptor)
+            throw new InternalError("Missing descriptor. Should be impossible");
+        metadata(Transaction.key(TransactionalKeys.TRANSACTIONAL), data)(target, propertyKey);
+        const originalMethod = descriptor.value;
+        const methodWrapper = function (...args) {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const self = this;
+            return new Promise((resolve, reject) => {
+                const cb = (err, result) => {
+                    Transaction.release(err).then(() => {
+                        if (err)
+                            return reject(err);
+                        resolve(result);
+                    });
+                };
+                let transaction = args.shift();
+                if (transaction instanceof Transaction) {
+                    const updatedTransaction = new Transaction(this.constructor.name, propertyKey, async () => {
+                        originalMethod
+                            .call(updatedTransaction.bindToTransaction(self), ...args)
+                            .then(resolve)
+                            .catch(reject);
+                    }, data.length ? data : undefined);
+                    transaction.bindTransaction(updatedTransaction);
+                    transaction.fire();
+                }
+                else {
+                    args.unshift(transaction);
+                    transaction = new Transaction(this.constructor.name, propertyKey, () => {
+                        originalMethod
+                            .call(transaction.bindToTransaction(self), ...args)
+                            .then((result) => cb(undefined, result))
+                            .catch(cb);
+                    }, data.length ? data : undefined);
+                    Transaction.submit(transaction);
+                }
+            });
+        };
+        Object.defineProperty(methodWrapper, "name", {
+            value: propertyKey,
+        });
+        descriptor.value = methodWrapper;
+    };
+}
+//
+// /**
+//  * @summary Sets a class Async method as transactional
+//  *
+//  * @param {any[]}  [metadata] option metadata available to the {@link TransactionLock}
+//  *
+//  * @function transactionalAsync
+//  *
+//  * @memberOf module:db-decorators.Decorators.transactions
+//  */
+// export function transactionalAsync(...metadata: any[]) {
+//   return function (
+//     target: any,
+//     propertyKey: string,
+//     descriptor: PropertyDescriptor,
+//   ) {
+//     metadasta(getTransactionalKey(TransactionalKeys.TRANSACTIONAL))
+//     Reflect.defineMetadata(
+//       ,
+//       {
+//         type: "async",
+//         metadata: metadata.length ? metadata : undefined,
+//       } as TransactionalMetadata,
+//       target,
+//       propertyKey,
+//     );
+//
+//     const originalMethod = descriptor.value;
+//
+//     const methodWrapper = function (this: any, ...args: any[]) {
+//       const callback: Callback = args.pop();
+//       if (!callback || typeof callback !== "function")
+//         throw new CriticalError(`Missing Callback`);
+//
+//       const cb = (err?: Err, ...args: any[]) => {
+//         Transaction.release(err).then((_) => callback(err, ...args));
+//       };
+//
+//       const self = this;
+//
+//       let transaction = args.shift();
+//       if (transaction instanceof Transaction) {
+//         const updatedTransaction: Transaction = new Transaction(
+//           this.constructor.name,
+//           propertyKey,
+//           () => {
+//             try {
+//               return originalMethod.call(
+//                 updatedTransaction.bindToTransaction(self),
+//                 ...args,
+//                 callback,
+//               );
+//             } catch (e: any) {
+//               return callback(e);
+//             }
+//           },
+//           metadata.length ? metadata : undefined,
+//         );
+//
+//         transaction.bindTransaction(updatedTransaction);
+//         transaction.fire();
+//       } else {
+//         args.unshift(transaction);
+//         transaction = undefined;
+//         transaction = new Transaction(
+//           this.constructor.name,
+//           propertyKey,
+//           () => {
+//             try {
+//               return originalMethod.call(
+//                 transaction.bindToTransaction(self),
+//                 ...args,
+//                 cb,
+//               );
+//             } catch (e: any) {
+//               return cb(e);
+//             }
+//           },
+//           metadata.length ? metadata : undefined,
+//         );
+//         Transaction.submit(transaction);
+//       }
+//     };
+//
+//     Object.defineProperty(methodWrapper, "name", {
+//       value: propertyKey,
+//     });
+//     descriptor.value = methodWrapper;
+//   };
+// }
+/**
+ * @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
+ */
+function transactionalSuperCall(method, ...args) {
+    const lock = Transaction.getLock();
+    const currentTransaction = lock.currentTransaction;
+    return method(currentTransaction, ...args);
+}
+
+/**
+ * @summary Module summary
+ * @description Module description
+ * @module ts-workspace
+ */
+/**
+ * @summary Namespace summary
+ * @description Namespace description
+ * @namespace Namespace
+ * @memberOf module:ts-workspace
+ */
+/**
+ * @summary stores the current package version
+ * @description this is how you should document a constant
+ * @const VERSION
+ * @memberOf module:ts-workspace
+ */
+const VERSION = "0.1.0";
+
+export { Lock, SyncronousLock, Transaction, TransactionalKeys, VERSION, transactional, transactionalSuperCall };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"transactional-decorators.esm.cjs","sources":["../src/locks/Lock.ts","../src/locks/SyncronousLock.ts","../src/constants.ts","../src/utils.ts","../src/Transaction.ts","../src/decorators.ts","../src/index.ts"],"sourcesContent":["import { LockCallable } from \"../types\";\n\n/**\n * @summary Simple Promise based Lock class\n *\n * @class Lock\n * @category Transactions\n */\nexport class Lock {\n  private queue: LockCallable[] = [];\n  private locked = false;\n\n  /**\n   * @summary executes when lock is available\n   * @param {Function} func\n   */\n  async execute(func: () => any) {\n    await this.acquire();\n    let result: any;\n    try {\n      result = await Promise.resolve(func());\n    } catch (e: any) {\n      this.release();\n      throw e;\n    }\n    this.release();\n    return result;\n  }\n\n  /**\n   * @summary waits to acquire the lock\n   * @param {string} [issuer]\n   */\n  async acquire(): Promise<void> {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const self = this;\n    if (self.locked) {\n      return new Promise<void>((resolve) => self.queue.push(resolve));\n    } else {\n      self.locked = true;\n      return Promise.resolve();\n    }\n  }\n\n  /**\n   * @summary releases the lock\n   */\n  release() {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const self = this;\n    const next: LockCallable | undefined = self.queue.shift();\n    if (next) {\n      if (\n        typeof (globalThis as unknown as { window: any }).window === \"undefined\"\n      )\n        globalThis.process.nextTick(next); // if you are on node\n      else setTimeout(next, 0); // if you are in the browser\n    } else {\n      self.locked = false;\n    }\n  }\n}\n","/**\n * @summary Simple Synchronous Lock implementation\n * @description for transaction management\n * adapted from {@link https://www.talkinghightech.com/en/creating-a-js-lock-for-a-resource/}\n *\n * @param {number} [counter] the number of simultaneous transactions allowed. defaults to 1\n * @param {Function} [onBegin] to be called at the start of the transaction\n * @param {Function} [onEnd] to be called at the conclusion of the transaction\n *\n * @class SyncronousLock\n * @implements TransactionLock\n *\n * @category Transactions\n */ import { Transaction } from \"../Transaction\";\nimport { TransactionLock } from \"../interfaces/TransactionLock\";\nimport { Lock } from \"./Lock\";\n\nexport class SyncronousLock implements TransactionLock {\n  private counter: number;\n  private pendingTransactions: Transaction[];\n  currentTransaction?: Transaction = undefined;\n  private readonly onBegin?: () => Promise<void>;\n  private readonly onEnd?: (err?: Error) => Promise<void>;\n\n  private readonly lock = new Lock();\n\n  constructor(\n    counter: number = 1,\n    onBegin?: () => Promise<void>,\n    onEnd?: (err?: Error) => Promise<void>,\n  ) {\n    this.counter = counter;\n    this.pendingTransactions = [];\n    this.onBegin = onBegin;\n    this.onEnd = onEnd;\n  }\n\n  /**\n   * @summary Submits a transaction to be processed\n   * @param {Transaction} transaction\n   */\n  submit(transaction: Transaction): void {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const self = this;\n    self.lock.acquire().then(() => {\n      if (\n        self.currentTransaction &&\n        self.currentTransaction.id === transaction.id\n      ) {\n        self.lock.release();\n        return transaction.fire();\n      }\n\n      if (self.counter > 0) {\n        self.counter--;\n        self.lock.release();\n        return self.fireTransaction(transaction);\n      } else {\n        self.pendingTransactions.push(transaction);\n        self.lock.release();\n      }\n    });\n  }\n\n  /**\n   * @summary Executes a transaction\n   *\n   * @param {Transaction} transaction\n   * @private\n   */\n  private fireTransaction(transaction: Transaction) {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const self = this;\n    self.lock.acquire().then(() => {\n      self.currentTransaction = transaction;\n      self.lock.release();\n      if (self.onBegin)\n        self.onBegin().then(() => {\n          // all.call(\n          //   self,\n          //   `Firing transaction {0}. {1} remaining...`,\n          //   transaction.id,\n          //   this.pendingTransactions.length,\n          // );\n          transaction.fire();\n        });\n      else {\n        // all.call(\n        //   self,\n        //   `Firing transaction {0}. {1} remaining...`,\n        //   transaction.id,\n        //   this.pendingTransactions.length,\n        // );\n        transaction.fire();\n      }\n    });\n  }\n  /**\n   * @summary Releases The lock after the conclusion of a transaction\n   */\n  async release(err?: Error): Promise<void> {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const self = this;\n    return new Promise<void>((resolve) => {\n      self.lock.acquire().then(() => {\n        if (!self.currentTransaction)\n          console.warn(\n            \"Trying to release an unexisting transaction. should never happen...\",\n          );\n        // debug.call(\n        //   self,\n        //   \"Releasing transaction: {0}\",\n        //   self.currentTransaction?.toString(true, true),\n        // );\n        self.currentTransaction = undefined;\n        self.lock.release();\n\n        const afterConclusionCB = () => {\n          self.lock.acquire().then(() => {\n            if (self.pendingTransactions.length > 0) {\n              const transaction =\n                self.pendingTransactions.shift() as Transaction;\n\n              const cb = () => self.fireTransaction(transaction);\n              //\n              // all(\n              //   `Releasing Transaction Lock on transaction {0}`,\n              //   transaction.id,\n              // );\n\n              if (\n                typeof (globalThis as unknown as { window: any }).window ===\n                \"undefined\"\n              )\n                globalThis.process.nextTick(cb); // if you are on node\n              else setTimeout(cb, 0); // if you are in the browser\n            } else {\n              self.counter++;\n            }\n            self.lock.release();\n            resolve();\n          });\n        };\n\n        if (self.onEnd) self.onEnd(err).then(() => afterConclusionCB());\n        else afterConclusionCB();\n      });\n    });\n  }\n}\n","export const TransactionalKeys: Record<string, string> = {\n  REFLECT: \"model.transactional.\",\n  TRANSACTIONAL: \"transactional\",\n};\n","export function getObjectName(obj: any): string | undefined {\n  if (!obj) return;\n  if (typeof obj === \"string\") return obj;\n  if (\n    obj.constructor &&\n    obj.constructor.name &&\n    [\"Function\", \"Object\"].indexOf(obj.constructor.name) === -1\n  )\n    return obj.constructor.name;\n  if (typeof obj === \"function\" && obj.name) return obj.name;\n  return obj.toString();\n}\n","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","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","export * from \"./interfaces\";\nexport * from \"./locks\";\nexport * from \"./constants\";\nexport * from \"./decorators\";\nexport * from \"./Transaction\";\nexport * from \"./types\";\n\n/**\n * @summary Module summary\n * @description Module description\n * @module ts-workspace\n */\n\n/**\n * @summary Namespace summary\n * @description Namespace description\n * @namespace Namespace\n * @memberOf module:ts-workspace\n */\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:ts-workspace\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":[],"mappings":"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AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;;;;;;AAOG;SACa,sBAAsB,CAAC,MAAW,EAAE,GAAG,IAAS,EAAA;AAC9D,IAAA,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,EAAE;AAClC,IAAA,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB;AAClD,IAAA,OAAO,MAAM,CAAC,kBAAkB,EAAE,GAAG,IAAI,CAAC;AAC5C;;AChLA;;;;AAIG;AAEH;;;;;AAKG;AAEH;;;;;AAKG;AACI,MAAM,OAAO,GAAG;;;;"}

package/lib/Transaction.cjs

@@ -6,6 +6,18 @@ const SyncronousLock_1 = require("./locks/SyncronousLock.cjs");
 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]
+ *
+ * @class Transaction
+ *
+ * @category Transactions
+ */
 class Transaction {
     constructor(source, method, action, metadata) {
         this.id = Date.now();
@@ -148,3 +160,4 @@ class Transaction {
     }
 }
 exports.Transaction = Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Transaction.js","sourceRoot":"","sources":["../src/Transaction.ts"],"names":[],"mappings":";;;AACA,qDAAkD;AAElD,2DAAwD;AACxD,2DAGiC;AACjC,mCAAwC;AACxC,2CAAgD;AAEhD;;;;;;;;;;;GAWG;AACH,MAAa,WAAW;IAUtB,YACE,MAAc,EACd,MAAe,EACf,MAAkB,EAClB,QAAgB;QAEhB,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CACT,MAAW,EACX,cAAsD,EACtD,GAAG,IAAwB;QAE3B,MAAM,QAAQ,GAAa,IAAI,CAAC,GAAG,EAAE,CAAC;QACtC,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,UAAU;YAC7C,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;QACtC,MAAM,EAAE,GAAG,CAAC,GAAW,EAAE,GAAG,IAAW,EAAE,EAAE;YACzC,WAAW,CAAC,OAAO,EAAE;iBAClB,OAAO,CAAC,GAAG,CAAC;iBACZ,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;QACxC,CAAC,CAAC;QACF,MAAM,WAAW,GAAgB,IAAI,WAAW,CAC9C,MAAM,CAAC,WAAW,CAAC,IAAI,EACvB,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,IAAA,qBAAa,EAAC,cAAc,CAAC,CAAC,CAAC,CAAC,WAAW,EACjE,GAAG,EAAE;YACH,OAAO,cAAc,CAAC,IAAI,CACxB,WAAW,CAAC,iBAAiB,CAAC,MAAM,CAAC,EACrC,GAAG,IAAI,EACP,EAAE,CACH,CAAC;QACJ,CAAC,CACF,CAAC;QACF,WAAW,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,OAAO,CAAC,IAAqB;QAClC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,OAAO;QACZ,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,IAAI,CAAC,IAAI,GAAG,IAAI,+BAAc,EAAE,CAAC;QACjD,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,MAAM,CAAC,WAAwB;QACpC,WAAW,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAW;QAC9B,OAAO,WAAW,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACxD,CAAC;IAED;;;OAGG;IACH,eAAe,CAAC,eAA4B;QAC1C,wDAAwD;QACxD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;QACtC,eAAe,CAAC,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpE,eAAe,CAAC,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtE,IAAI,CAAC,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC;IACvC,CAAC;IAED;;;;;;;OAOG;IACH,iBAAiB,CAAC,GAAQ;QACxB,MAAM,oBAAoB,GAAG,IAAA,iDAAiC,EAC5D,GAAG,EACH,SAAS,EACT,6BAAiB,CAAC,OAAO,CAC1B,CAAC;QACF,IAAI,CAAC,oBAAoB;YAAE,OAAO,GAAG,CAAC;QACtC,4DAA4D;QAC5D,MAAM,IAAI,GAAG,IAAI,CAAC;QAElB,MAAM,QAAQ,GAAG,uBAAU,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,MAAM,CACtD,CAAC,KAAU,EAAE,CAAS,EAAE,EAAE;YACxB,IACE,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;gBACnD,oBAAoB,CAAC,CAAC,CAAC,CAAC,IAAI,CAC1B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,6BAAiB,CAAC,aAAa,CACjD;gBAED,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAW,EAAE,EAAE,CAC5B,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;iBACpD,IAAI,CAAC,KAAK,OAAO,IAAI,CAAC,KAAK,aAAa;gBAAE,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;iBAC5D,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,KAAK,UAAU;gBACnC,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,IAAI,GAAG,CAAC,CAAC;iBAC9C,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;gBAC1D,MAAM,IAAI,GAAG,uBAAU,CAAC,kBAAkB,CACxC,6BAAiB,CAAC,OAAO,EACzB,GAAG,CAAC,CAAC,CAAC,CACP,CAAC;gBACF,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,6BAAiB,CAAC,aAAa,CAAC;oBAClE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;;oBACvC,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;YACzB,CAAC;;gBAAM,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;YAEzB,OAAO,KAAK,CAAC;QACf,CAAC,EACD,EAAE,CACH,CAAC;QAEF,QAAQ,CAAC,sBAAM,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC,sBAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC;QACxD,QAAQ,CAAC,QAAQ,GAAG,GAAG,EAAE,CACvB,IAAA,qBAAa,EAAC,QAAQ,CAAC,sBAAM,CAAC,QAAQ,CAAC,CAAC;YACxC,yBAAyB;YACzB,IAAI,CAAC,EAAE,CAAC;QAEV,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;OAEG;IACH,IAAI;QACF,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;QACxD,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACH,QAAQ,CAAC,MAAM,GAAG,IAAI,EAAE,OAAO,GAAG,KAAK;QACrC,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,iBAAiB,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,GAC/E,OAAO,CAAC,CAAC,CAAC,wBAAwB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,GAC5D,EAAE,CAAC;IACL,CAAC;IAED;;;;;SAKK;IACL,MAAM,CAAC,GAAG,CAAC,GAAW;QACpB,OAAO,6BAAiB,CAAC,OAAO,GAAG,GAAG,CAAC;IACzC,CAAC;CACF;AAhMD,kCAgMC","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"]}