fix: 🐛 make concurrency() decorator apply per class instance

src/__tests__/concurrencyDecorator.spec.ts

@@ -35,6 +35,65 @@ test('can execute one function with limit 10', async () => {
   expect(res).toStrictEqual([123, 456, 1]);
 });
 
+test(`limits concurrency separately per method`, async () => {
+  const resA: number[] = [];
+  const resB: number[] = [];
+  class A {
+    @concurrency(2)
+    async a(timeout: number) {
+      await tick(timeout);
+      resA.push(timeout);
+    }
+    @concurrency(3)
+    async b(timeout: number) {
+      await tick(timeout);
+      resB.push(timeout);
+    }
+  }
+  const promises: Promise<any>[] = [];
+  const a = new A();
+  promises.push(a.a(3));
+  promises.push(a.a(4));
+  promises.push(a.a(10));
+  promises.push(a.b(2));
+  promises.push(a.b(3));
+  promises.push(a.b(4));
+  await tick(5);
+  expect(resA).toStrictEqual([3, 4]);
+  expect(resB).toStrictEqual([2, 3, 4]);
+  await Promise.all(promises);
+  expect(resA).toStrictEqual([3, 4, 10]);
+  expect(resB).toStrictEqual([2, 3, 4]);
+});
+
+test(`limits concurrency separately per instance`, async () => {
+  const resA: number[] = [];
+  const resB: number[] = [];
+  class A {
+    constructor (protected res: number[]) {}
+    @concurrency(2)
+    async a(timeout: number) {
+      await tick(timeout);
+      this.res.push(timeout);
+    }
+  }
+  const promises: Promise<any>[] = [];
+  const a = new A(resA);
+  const b = new A(resB);
+  promises.push(a.a(4));
+  promises.push(a.a(4));
+  promises.push(a.a(10));
+  promises.push(b.a(3));
+  promises.push(b.a(3));
+  promises.push(b.a(11));
+  await tick(5);
+  expect(resA).toStrictEqual([4, 4]);
+  expect(resB).toStrictEqual([3, 3]);
+  await Promise.all(promises);
+  expect(resA).toStrictEqual([4, 4, 10]);
+  expect(resB).toStrictEqual([3, 3, 11]);
+});
+
 describe('limits concurrency to 1', () => {
   for (let i = 0; i < 10; i++) {
     test(`${i + 1}`, async () => {

src/concurrencyDecorator.ts

@@ -1,18 +1,22 @@
 import {concurrency as _concurrency} from './concurrency';
 
+const instances = new WeakMap<any, WeakMap<any, any>>();
+
 /**
  * A class method decorator that limits the concurrency of the method to the
  * given number of parallel executions. All invocations are queued and executed
  * in the order they were called.
  */
 export function concurrency<This, Args extends any[], Return>(limit: number) {
   return (
-    target: (this: This, ...args: Args) => Promise<Return>,
+    fn: (this: This, ...args: Args) => Promise<Return>,
     context?: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Promise<Return>>,
   ) => {
-    const limiter = _concurrency(limit);
     return async function (this: This, ...args: Args): Promise<Return> {
-      return limiter(async () => await target.call(this, ...args));
+      let map = instances.get(this);
+      if (!map) instances.set(this, map = new WeakMap<any, any>());
+      if (!map.has(fn)) map.set(fn, _concurrency(limit));
+      return map.get(fn)!(async () => await fn.call(this, ...args));
     };
   };
 }

src/mutex.ts

@@ -3,9 +3,6 @@ import {codeMutex} from './codeMutex';
 /**
  * Executes only one instance of give code at a time. For parallel calls, it
  * returns the result of the ongoing execution.
- *
- * {@link mutex} can be used as a class method decorator or a higher order
- * function.
  */
 export function mutex<This, Args extends any[], Return>(
   target: (this: This, ...args: Args) => Promise<Return>,