@decaf-ts/transactional-decorators 0.0.22 → 0.1.1

package/README.md

@@ -37,6 +37,13 @@ Documentation available [here](https://decaf-ts.github.io/transactional-decorato
 
 ### Description
 
+Standalone module, exposes a simple implementation to handle concurrency:
+- Simple yet powerful locking;
+- decorate methods as `@transactional()` for control;
+- decorate classes as `@Transactional()`, enabling Instance proxying and keeping transactions across different classes/method calls (grouping several calls in a sing transaction)l
+- Customizable Transaction Lock;
+- Seamless integration with `db-decorators`;
+
 ### How to Use
 
 - [Initial Setup](./tutorials/For%20Developers.md#_initial-setup_)

package/dist/transactional-decorators.cjs

@@ -0,0 +1,544 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@decaf-ts/reflection'), require('@decaf-ts/db-decorators')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@decaf-ts/reflection', '@decaf-ts/db-decorators'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["transactional-decorators"] = {}, global.reflection, global.dbDecorators));
+})(this, (function (exports, reflection, dbDecorators) { 'use strict';
+
+    /**
+     * @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 = dbDecorators.getAllPropertyDecoratorsRecursive(obj, undefined, TransactionalKeys.REFLECT);
+            if (!transactionalMethods)
+                return obj;
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const self = this;
+            const boundObj = reflection.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.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[dbDecorators.DBKeys.ORIGINAL] = obj[dbDecorators.DBKeys.ORIGINAL] || obj;
+            boundObj.toString = () => getObjectName(boundObj[dbDecorators.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 dbDecorators.InternalError("Missing descriptor. Should be impossible");
+            reflection.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.1";
+
+    exports.Lock = Lock;
+    exports.SyncronousLock = SyncronousLock;
+    exports.Transaction = Transaction;
+    exports.TransactionalKeys = TransactionalKeys;
+    exports.VERSION = VERSION;
+    exports.transactional = transactional;
+    exports.transactionalSuperCall = transactionalSuperCall;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"transactional-decorators.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":["getAllPropertyDecoratorsRecursive","Reflection","DBKeys","InternalError","metadata"],"mappings":"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IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IAEA;;;;;;;IAOG;aACa,sBAAsB,CAAC,MAAW,EAAE,GAAG,IAAS,EAAA;IAC9D,IAAA,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,EAAE;IAClC,IAAA,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB;IAClD,IAAA,OAAO,MAAM,CAAC,kBAAkB,EAAE,GAAG,IAAI,CAAC;IAC5C;;IChLA;;;;IAIG;IAEH;;;;;IAKG;IAEH;;;;;IAKG;AACI,UAAM,OAAO,GAAG;;;;;;;;;;;;;;"}